base mod created

build/tmp/recompileMc/sources/net/minecraft/advancements/Advancement.java

@@ -0,0 +1,388 @@
+package net.minecraft.advancements;
+
+import com.google.common.collect.ImmutableMap;
+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.io.IOException;
+import java.util.Arrays;
+import java.util.Map;
+import java.util.Set;
+import java.util.function.Function;
+import javax.annotation.Nullable;
+import net.minecraft.network.PacketBuffer;
+import net.minecraft.util.JsonUtils;
+import net.minecraft.util.ResourceLocation;
+import net.minecraft.util.text.ITextComponent;
+import net.minecraft.util.text.TextComponentString;
+import net.minecraft.util.text.event.HoverEvent;
+import net.minecraftforge.fml.relauncher.Side;
+import net.minecraftforge.fml.relauncher.SideOnly;
+import org.apache.commons.lang3.ArrayUtils;
+
+public class Advancement
+{
+    private final Advancement parent;
+    private final DisplayInfo display;
+    private final AdvancementRewards rewards;
+    private final ResourceLocation id;
+    private final Map<String, Criterion> criteria;
+    private final String[][] requirements;
+    private final Set<Advancement> children = Sets.<Advancement>newLinkedHashSet();
+    private final ITextComponent displayText;
+
+    public Advancement(ResourceLocation id, @Nullable Advancement parentIn, @Nullable DisplayInfo displayIn, AdvancementRewards rewardsIn, Map<String, Criterion> criteriaIn, String[][] requirementsIn)
+    {
+        this.id = id;
+        this.display = displayIn;
+        this.criteria = ImmutableMap.copyOf(criteriaIn);
+        this.parent = parentIn;
+        this.rewards = rewardsIn;
+        this.requirements = requirementsIn;
+
+        if (parentIn != null)
+        {
+            parentIn.addChild(this);
+        }
+
+        if (displayIn == null)
+        {
+            this.displayText = new TextComponentString(id.toString());
+        }
+        else
+        {
+            this.displayText = new TextComponentString("[");
+            this.displayText.getStyle().setColor(displayIn.getFrame().getFormat());
+            ITextComponent itextcomponent = displayIn.getTitle().createCopy();
+            ITextComponent itextcomponent1 = new TextComponentString("");
+            ITextComponent itextcomponent2 = itextcomponent.createCopy();
+            itextcomponent2.getStyle().setColor(displayIn.getFrame().getFormat());
+            itextcomponent1.appendSibling(itextcomponent2);
+            itextcomponent1.appendText("\n");
+            itextcomponent1.appendSibling(displayIn.getDescription());
+            itextcomponent.getStyle().setHoverEvent(new HoverEvent(HoverEvent.Action.SHOW_TEXT, itextcomponent1));
+            this.displayText.appendSibling(itextcomponent);
+            this.displayText.appendText("]");
+        }
+    }
+
+    /**
+     * Creates a new advancement builder with the data from this advancement
+     */
+    public Advancement.Builder copy()
+    {
+        return new Advancement.Builder(this.parent == null ? null : this.parent.getId(), this.display, this.rewards, this.criteria, this.requirements);
+    }
+
+    /**
+     * Get the {@code Advancement} that is this {@code Advancement}'s parent. This determines the tree structure that
+     * appears in the {@linkplain GuiScreenAdvancements GUI}.
+     * 
+     * @return the parent {@code Advancement} of this {@code Advancement}, or {@code null} to signify that this {@code
+     * Advancement} is a root with no parent.
+     */
+    @Nullable
+    public Advancement getParent()
+    {
+        return this.parent;
+    }
+
+    /**
+     * Get information that defines this {@code Advancement}'s appearance in GUIs.
+     * 
+     * @return information that defines this {@code Advancement}'s appearance in GUIs. If {@code null}, signifies an
+     * invisible {@code Advancement}.
+     */
+    @Nullable
+    public DisplayInfo getDisplay()
+    {
+        return this.display;
+    }
+
+    public AdvancementRewards getRewards()
+    {
+        return this.rewards;
+    }
+
+    public String toString()
+    {
+        return "SimpleAdvancement{id=" + this.getId() + ", parent=" + (this.parent == null ? "null" : this.parent.getId()) + ", display=" + this.display + ", rewards=" + this.rewards + ", criteria=" + this.criteria + ", requirements=" + Arrays.deepToString(this.requirements) + '}';
+    }
+
+    /**
+     * Get the children of this {@code Advancement}.
+     * 
+     * @return an {@code Iterable} of this {@code Advancement}'s children.
+     * @see #getParent()
+     */
+    public Iterable<Advancement> getChildren()
+    {
+        return this.children;
+    }
+
+    /**
+     * Get the {@link Criterion Criteria} used to decide the completion of this {@code Advancement}. Each key-value pair
+     * consists of a {@code Criterion} and its name.
+     * 
+     * @return the criteria used to decide the completion of this {@code Advancement}
+     * @see #getRequirements()
+     */
+    public Map<String, Criterion> getCriteria()
+    {
+        return this.criteria;
+    }
+
+    /**
+     * Get how many requirements this {@code Advancement} has.
+     * 
+     * @return {@code this.getRequirements().length}
+     * @see #getRequirements()
+     */
+    @SideOnly(Side.CLIENT)
+    public int getRequirementCount()
+    {
+        return this.requirements.length;
+    }
+
+    /**
+     * Add the given {@code Advancement} as a child of this {@code Advancement}.
+     * 
+     * @see #getParent()
+     */
+    public void addChild(Advancement advancementIn)
+    {
+        this.children.add(advancementIn);
+    }
+
+    /**
+     * Get this {@code Advancement}'s unique identifier.
+     * 
+     * @return this {@code Advancement}'s unique identifier
+     */
+    public ResourceLocation getId()
+    {
+        return this.id;
+    }
+
+    public boolean equals(Object p_equals_1_)
+    {
+        if (this == p_equals_1_)
+        {
+            return true;
+        }
+        else if (!(p_equals_1_ instanceof Advancement))
+        {
+            return false;
+        }
+        else
+        {
+            Advancement advancement = (Advancement)p_equals_1_;
+            return this.id.equals(advancement.id);
+        }
+    }
+
+    public int hashCode()
+    {
+        return this.id.hashCode();
+    }
+
+    public String[][] getRequirements()
+    {
+        return this.requirements;
+    }
+
+    /**
+     * Returns the {@code ITextComponent} that is shown in the chat message sent after this {@code Advancement} is
+     * completed.
+     * 
+     * @return the {@code ITextComponent} that is shown in the chat message sent after this {@code Advancement} is
+     * completed. If this {@code Advancement} is {@linkplain #getDisplay() invisible}, then it consists simply of {@link
+     * #getId()}. Otherwise, it is the {@linkplain DisplayInfo#getTitle() title} inside square brackets, colored by the
+     * {@linkplain net.minecraft.advancements.FrameType#getFormat frame type}, and hovering over it shows the
+     * {@linkplain DisplayInfo#getDescription() description}.
+     */
+    public ITextComponent getDisplayText()
+    {
+        return this.displayText;
+    }
+
+    public static class Builder
+        {
+            private final ResourceLocation parentId;
+            private Advancement parent;
+            private final DisplayInfo display;
+            private final AdvancementRewards rewards;
+            private final Map<String, Criterion> criteria;
+            private final String[][] requirements;
+
+            Builder(@Nullable ResourceLocation p_i47414_1_, @Nullable DisplayInfo p_i47414_2_, AdvancementRewards p_i47414_3_, Map<String, Criterion> p_i47414_4_, String[][] p_i47414_5_)
+            {
+                this.parentId = p_i47414_1_;
+                this.display = p_i47414_2_;
+                this.rewards = p_i47414_3_;
+                this.criteria = p_i47414_4_;
+                this.requirements = p_i47414_5_;
+            }
+
+            /**
+             * Tries to resolve the parent of this advancement, if possible. Returns true on success.
+             */
+            public boolean resolveParent(Function<ResourceLocation, Advancement> lookup)
+            {
+                if (this.parentId == null)
+                {
+                    return true;
+                }
+                else
+                {
+                    this.parent = lookup.apply(this.parentId);
+                    return this.parent != null;
+                }
+            }
+
+            public Advancement build(ResourceLocation id)
+            {
+                return new Advancement(id, this.parent, this.display, this.rewards, this.criteria, this.requirements);
+            }
+
+            public void writeTo(PacketBuffer buf)
+            {
+                if (this.parentId == null)
+                {
+                    buf.writeBoolean(false);
+                }
+                else
+                {
+                    buf.writeBoolean(true);
+                    buf.writeResourceLocation(this.parentId);
+                }
+
+                if (this.display == null)
+                {
+                    buf.writeBoolean(false);
+                }
+                else
+                {
+                    buf.writeBoolean(true);
+                    this.display.write(buf);
+                }
+
+                Criterion.serializeToNetwork(this.criteria, buf);
+                buf.writeVarInt(this.requirements.length);
+
+                for (String[] astring : this.requirements)
+                {
+                    buf.writeVarInt(astring.length);
+
+                    for (String s : astring)
+                    {
+                        buf.writeString(s);
+                    }
+                }
+            }
+
+            public String toString()
+            {
+                return "Task Advancement{parentId=" + this.parentId + ", display=" + this.display + ", rewards=" + this.rewards + ", criteria=" + this.criteria + ", requirements=" + Arrays.deepToString(this.requirements) + '}';
+            }
+
+            public static Advancement.Builder deserialize(JsonObject json, JsonDeserializationContext context)
+            {
+                ResourceLocation resourcelocation = json.has("parent") ? new ResourceLocation(JsonUtils.getString(json, "parent")) : null;
+                DisplayInfo displayinfo = json.has("display") ? DisplayInfo.deserialize(JsonUtils.getJsonObject(json, "display"), context) : null;
+                AdvancementRewards advancementrewards = (AdvancementRewards)JsonUtils.deserializeClass(json, "rewards", AdvancementRewards.EMPTY, context, AdvancementRewards.class);
+                Map<String, Criterion> map = Criterion.criteriaFromJson(JsonUtils.getJsonObject(json, "criteria"), context);
+
+                if (map.isEmpty())
+                {
+                    throw new JsonSyntaxException("Advancement criteria cannot be empty");
+                }
+                else
+                {
+                    JsonArray jsonarray = JsonUtils.getJsonArray(json, "requirements", new JsonArray());
+                    String[][] astring = new String[jsonarray.size()][];
+
+                    for (int i = 0; i < jsonarray.size(); ++i)
+                    {
+                        JsonArray jsonarray1 = JsonUtils.getJsonArray(jsonarray.get(i), "requirements[" + i + "]");
+                        astring[i] = new String[jsonarray1.size()];
+
+                        for (int j = 0; j < jsonarray1.size(); ++j)
+                        {
+                            astring[i][j] = JsonUtils.getString(jsonarray1.get(j), "requirements[" + i + "][" + j + "]");
+                        }
+                    }
+
+                    if (astring.length == 0)
+                    {
+                        astring = new String[map.size()][];
+                        int k = 0;
+
+                        for (String s2 : map.keySet())
+                        {
+                            astring[k++] = new String[] {s2};
+                        }
+                    }
+
+                    for (String[] astring1 : astring)
+                    {
+                        if (astring1.length == 0 && map.isEmpty())
+                        {
+                            throw new JsonSyntaxException("Requirement entry cannot be empty");
+                        }
+
+                        for (String s : astring1)
+                        {
+                            if (!map.containsKey(s))
+                            {
+                                throw new JsonSyntaxException("Unknown required criterion '" + s + "'");
+                            }
+                        }
+                    }
+
+                    for (String s1 : map.keySet())
+                    {
+                        boolean flag = false;
+
+                        for (String[] astring2 : astring)
+                        {
+                            if (ArrayUtils.contains(astring2, s1))
+                            {
+                                flag = true;
+                                break;
+                            }
+                        }
+
+                        if (!flag)
+                        {
+                            throw new JsonSyntaxException("Criterion '" + s1 + "' isn't a requirement for completion. This isn't supported behaviour, all criteria must be required.");
+                        }
+                    }
+
+                    return new Advancement.Builder(resourcelocation, displayinfo, advancementrewards, map, astring);
+                }
+            }
+
+            public static Advancement.Builder readFrom(PacketBuffer buf) throws IOException
+            {
+                ResourceLocation resourcelocation = buf.readBoolean() ? buf.readResourceLocation() : null;
+                DisplayInfo displayinfo = buf.readBoolean() ? DisplayInfo.read(buf) : null;
+                Map<String, Criterion> map = Criterion.criteriaFromNetwork(buf);
+                String[][] astring = new String[buf.readVarInt()][];
+
+                for (int i = 0; i < astring.length; ++i)
+                {
+                    astring[i] = new String[buf.readVarInt()];
+
+                    for (int j = 0; j < astring[i].length; ++j)
+                    {
+                        astring[i][j] = buf.readString(32767);
+                    }
+                }
+
+                return new Advancement.Builder(resourcelocation, displayinfo, AdvancementRewards.EMPTY, map, astring);
+            }
+        }
+}

build/tmp/recompileMc/sources/net/minecraft/advancements/AdvancementList.java

@@ -0,0 +1,201 @@
+package net.minecraft.advancements;
+
+import com.google.common.base.Functions;
+import com.google.common.collect.Maps;
+import com.google.common.collect.Sets;
+import java.util.Iterator;
+import java.util.Map;
+import java.util.Set;
+import java.util.Map.Entry;
+import java.util.function.Function;
+import javax.annotation.Nullable;
+import net.minecraft.util.ResourceLocation;
+import net.minecraftforge.fml.relauncher.Side;
+import net.minecraftforge.fml.relauncher.SideOnly;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+public class AdvancementList
+{
+    private static final Logger LOGGER = LogManager.getLogger();
+    private final Map<ResourceLocation, Advancement> advancements = Maps.<ResourceLocation, Advancement>newHashMap();
+    /** All advancements that do not have a parent. */
+    private final Set<Advancement> roots = Sets.<Advancement>newLinkedHashSet();
+    private final Set<Advancement> nonRoots = Sets.<Advancement>newLinkedHashSet();
+    private AdvancementList.Listener listener;
+
+    @SideOnly(Side.CLIENT)
+    private void remove(Advancement advancementIn)
+    {
+        for (Advancement advancement : advancementIn.getChildren())
+        {
+            this.remove(advancement);
+        }
+
+        LOGGER.info("Forgot about advancement " + advancementIn.getId());
+        this.advancements.remove(advancementIn.getId());
+
+        if (advancementIn.getParent() == null)
+        {
+            this.roots.remove(advancementIn);
+
+            if (this.listener != null)
+            {
+                this.listener.rootAdvancementRemoved(advancementIn);
+            }
+        }
+        else
+        {
+            this.nonRoots.remove(advancementIn);
+
+            if (this.listener != null)
+            {
+                this.listener.nonRootAdvancementRemoved(advancementIn);
+            }
+        }
+    }
+
+    @SideOnly(Side.CLIENT)
+    public void removeAll(Set<ResourceLocation> ids)
+    {
+        for (ResourceLocation resourcelocation : ids)
+        {
+            Advancement advancement = this.advancements.get(resourcelocation);
+
+            if (advancement == null)
+            {
+                LOGGER.warn("Told to remove advancement " + resourcelocation + " but I don't know what that is");
+            }
+            else
+            {
+                this.remove(advancement);
+            }
+        }
+    }
+
+    public void loadAdvancements(Map<ResourceLocation, Advancement.Builder> advancementsIn)
+    {
+        Function<ResourceLocation, Advancement> function = Functions.<ResourceLocation, Advancement>forMap(this.advancements, null);
+        label42:
+
+        while (!advancementsIn.isEmpty())
+        {
+            boolean flag = false;
+            Iterator<Entry<ResourceLocation, Advancement.Builder>> iterator = advancementsIn.entrySet().iterator();
+
+            while (iterator.hasNext())
+            {
+                Entry<ResourceLocation, Advancement.Builder> entry = (Entry)iterator.next();
+                ResourceLocation resourcelocation = entry.getKey();
+                Advancement.Builder advancement$builder = entry.getValue();
+
+                if (advancement$builder.resolveParent(function))
+                {
+                    Advancement advancement = advancement$builder.build(resourcelocation);
+                    this.advancements.put(resourcelocation, advancement);
+                    flag = true;
+                    iterator.remove();
+
+                    if (advancement.getParent() == null)
+                    {
+                        this.roots.add(advancement);
+
+                        if (this.listener != null)
+                        {
+                            this.listener.rootAdvancementAdded(advancement);
+                        }
+                    }
+                    else
+                    {
+                        this.nonRoots.add(advancement);
+
+                        if (this.listener != null)
+                        {
+                            this.listener.nonRootAdvancementAdded(advancement);
+                        }
+                    }
+                }
+            }
+
+            if (!flag)
+            {
+                iterator = advancementsIn.entrySet().iterator();
+
+                while (true)
+                {
+                    if (!iterator.hasNext())
+                    {
+                        break label42;
+                    }
+
+                    Entry<ResourceLocation, Advancement.Builder> entry1 = (Entry)iterator.next();
+                    LOGGER.error("Couldn't load advancement " + entry1.getKey() + ": " + entry1.getValue());
+                }
+            }
+        }
+
+        LOGGER.info("Loaded " + this.advancements.size() + " advancements");
+    }
+
+    public void clear()
+    {
+        this.advancements.clear();
+        this.roots.clear();
+        this.nonRoots.clear();
+
+        if (this.listener != null)
+        {
+            this.listener.advancementsCleared();
+        }
+    }
+
+    public Iterable<Advancement> getRoots()
+    {
+        return this.roots;
+    }
+
+    public Iterable<Advancement> getAdvancements()
+    {
+        return this.advancements.values();
+    }
+
+    @Nullable
+    public Advancement getAdvancement(ResourceLocation id)
+    {
+        return this.advancements.get(id);
+    }
+
+    @SideOnly(Side.CLIENT)
+    public void setListener(@Nullable AdvancementList.Listener listenerIn)
+    {
+        this.listener = listenerIn;
+
+        if (listenerIn != null)
+        {
+            for (Advancement advancement : this.roots)
+            {
+                listenerIn.rootAdvancementAdded(advancement);
+            }
+
+            for (Advancement advancement1 : this.nonRoots)
+            {
+                listenerIn.nonRootAdvancementAdded(advancement1);
+            }
+        }
+    }
+
+    public interface Listener
+    {
+        void rootAdvancementAdded(Advancement advancementIn);
+
+        @SideOnly(Side.CLIENT)
+        void rootAdvancementRemoved(Advancement advancementIn);
+
+        void nonRootAdvancementAdded(Advancement advancementIn);
+
+        @SideOnly(Side.CLIENT)
+        void nonRootAdvancementRemoved(Advancement advancementIn);
+
+        void advancementsCleared();
+    }
+}

build/tmp/recompileMc/sources/net/minecraft/advancements/AdvancementManager.java

@@ -0,0 +1,234 @@
+package net.minecraft.advancements;
+
+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.JsonDeserializer;
+import com.google.gson.JsonElement;
+import com.google.gson.JsonObject;
+import com.google.gson.JsonParseException;
+import java.io.BufferedReader;
+import java.io.Closeable;
+import java.io.File;
+import java.io.IOException;
+import java.io.Reader;
+import java.lang.reflect.Type;
+import java.net.URI;
+import java.net.URISyntaxException;
+import java.net.URL;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.FileSystem;
+import java.nio.file.FileSystems;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.util.Collections;
+import java.util.Iterator;
+import java.util.Map;
+import javax.annotation.Nullable;
+import net.minecraft.item.crafting.CraftingManager;
+import net.minecraft.util.EnumTypeAdapterFactory;
+import net.minecraft.util.JsonUtils;
+import net.minecraft.util.ResourceLocation;
+import net.minecraft.util.text.ITextComponent;
+import net.minecraft.util.text.Style;
+import org.apache.commons.io.FileUtils;
+import org.apache.commons.io.FilenameUtils;
+import org.apache.commons.io.IOUtils;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+public class AdvancementManager
+{
+    private static final Logger LOGGER = LogManager.getLogger();
+    public static final Gson GSON = (new GsonBuilder()).registerTypeHierarchyAdapter(Advancement.Builder.class, new JsonDeserializer<Advancement.Builder>()
+    {
+        public Advancement.Builder deserialize(JsonElement p_deserialize_1_, Type p_deserialize_2_, JsonDeserializationContext p_deserialize_3_) throws JsonParseException
+        {
+            JsonObject jsonobject = JsonUtils.getJsonObject(p_deserialize_1_, "advancement");
+            return Advancement.Builder.deserialize(jsonobject, p_deserialize_3_);
+        }
+    }).registerTypeAdapter(AdvancementRewards.class, new AdvancementRewards.Deserializer()).registerTypeHierarchyAdapter(ITextComponent.class, new ITextComponent.Serializer()).registerTypeHierarchyAdapter(Style.class, new Style.Serializer()).registerTypeAdapterFactory(new EnumTypeAdapterFactory()).create();
+    private static final AdvancementList ADVANCEMENT_LIST = new AdvancementList();
+    /** The directory where this manager looks for custom advancement files. */
+    private final File advancementsDir;
+    private boolean hasErrored;
+
+    public AdvancementManager(@Nullable File advancementsDirIn)
+    {
+        this.advancementsDir = advancementsDirIn;
+        this.reload();
+    }
+
+    public void reload()
+    {
+        this.hasErrored = false;
+        ADVANCEMENT_LIST.clear();
+        Map<ResourceLocation, Advancement.Builder> map = this.loadCustomAdvancements();
+        this.loadBuiltInAdvancements(map);
+        this.hasErrored |= net.minecraftforge.common.ForgeHooks.loadAdvancements(map);
+        ADVANCEMENT_LIST.loadAdvancements(map);
+
+        for (Advancement advancement : ADVANCEMENT_LIST.getRoots())
+        {
+            if (advancement.getDisplay() != null)
+            {
+                AdvancementTreeNode.layout(advancement);
+            }
+        }
+    }
+
+    public boolean hasErrored()
+    {
+        return this.hasErrored;
+    }
+
+    private Map<ResourceLocation, Advancement.Builder> loadCustomAdvancements()
+    {
+        if (this.advancementsDir == null)
+        {
+            return Maps.<ResourceLocation, Advancement.Builder>newHashMap();
+        }
+        else
+        {
+            Map<ResourceLocation, Advancement.Builder> map = Maps.<ResourceLocation, Advancement.Builder>newHashMap();
+            this.advancementsDir.mkdirs();
+
+            for (File file1 : FileUtils.listFiles(this.advancementsDir, new String[] {"json"}, true))
+            {
+                String s = FilenameUtils.removeExtension(this.advancementsDir.toURI().relativize(file1.toURI()).toString());
+                String[] astring = s.split("/", 2);
+
+                if (astring.length == 2)
+                {
+                    ResourceLocation resourcelocation = new ResourceLocation(astring[0], astring[1]);
+
+                    try
+                    {
+                        Advancement.Builder advancement$builder = (Advancement.Builder)JsonUtils.gsonDeserialize(GSON, FileUtils.readFileToString(file1, StandardCharsets.UTF_8), Advancement.Builder.class);
+
+                        if (advancement$builder == null)
+                        {
+                            LOGGER.error("Couldn't load custom advancement " + resourcelocation + " from " + file1 + " as it's empty or null");
+                        }
+                        else
+                        {
+                            map.put(resourcelocation, advancement$builder);
+                        }
+                    }
+                    catch (IllegalArgumentException | JsonParseException jsonparseexception)
+                    {
+                        LOGGER.error("Parsing error loading custom advancement " + resourcelocation, (Throwable)jsonparseexception);
+                        this.hasErrored = true;
+                    }
+                    catch (IOException ioexception)
+                    {
+                        LOGGER.error("Couldn't read custom advancement " + resourcelocation + " from " + file1, (Throwable)ioexception);
+                        this.hasErrored = true;
+                    }
+                }
+            }
+            return map;
+        }
+    }
+
+    private void loadBuiltInAdvancements(Map<ResourceLocation, Advancement.Builder> map)
+    {
+        FileSystem filesystem = null;
+
+        try
+        {
+            URL url = AdvancementManager.class.getResource("/assets/.mcassetsroot");
+
+            if (url != null)
+            {
+                URI uri = url.toURI();
+                Path path;
+
+                if ("file".equals(uri.getScheme()))
+                {
+                    path = Paths.get(CraftingManager.class.getResource("/assets/minecraft/advancements").toURI());
+                }
+                else
+                {
+                    if (!"jar".equals(uri.getScheme()))
+                    {
+                        LOGGER.error("Unsupported scheme " + uri + " trying to list all built-in advancements (NYI?)");
+                        this.hasErrored = true;
+                        return;
+                    }
+
+                    filesystem = FileSystems.newFileSystem(uri, Collections.emptyMap());
+                    path = filesystem.getPath("/assets/minecraft/advancements");
+                }
+
+                Iterator<Path> iterator = Files.walk(path).iterator();
+
+                while (iterator.hasNext())
+                {
+                    Path path1 = iterator.next();
+
+                    if ("json".equals(FilenameUtils.getExtension(path1.toString())))
+                    {
+                        Path path2 = path.relativize(path1);
+                        String s = FilenameUtils.removeExtension(path2.toString()).replaceAll("\\\\", "/");
+                        ResourceLocation resourcelocation = new ResourceLocation("minecraft", s);
+
+                        if (!map.containsKey(resourcelocation))
+                        {
+                            BufferedReader bufferedreader = null;
+
+                            try
+                            {
+                                bufferedreader = Files.newBufferedReader(path1);
+                                Advancement.Builder advancement$builder = (Advancement.Builder)JsonUtils.fromJson(GSON, bufferedreader, Advancement.Builder.class);
+                                map.put(resourcelocation, advancement$builder);
+                            }
+                            catch (JsonParseException jsonparseexception)
+                            {
+                                LOGGER.error("Parsing error loading built-in advancement " + resourcelocation, (Throwable)jsonparseexception);
+                                this.hasErrored = true;
+                            }
+                            catch (IOException ioexception)
+                            {
+                                LOGGER.error("Couldn't read advancement " + resourcelocation + " from " + path1, (Throwable)ioexception);
+                                this.hasErrored = true;
+                            }
+                            finally
+                            {
+                                IOUtils.closeQuietly((Reader)bufferedreader);
+                            }
+                        }
+                    }
+                }
+
+                return;
+            }
+
+            LOGGER.error("Couldn't find .mcassetsroot");
+            this.hasErrored = true;
+        }
+        catch (IOException | URISyntaxException urisyntaxexception)
+        {
+            LOGGER.error("Couldn't get a list of all built-in advancement files", (Throwable)urisyntaxexception);
+            this.hasErrored = true;
+            return;
+        }
+        finally
+        {
+            IOUtils.closeQuietly((Closeable)filesystem);
+        }
+    }
+
+    @Nullable
+    public Advancement getAdvancement(ResourceLocation id)
+    {
+        return ADVANCEMENT_LIST.getAdvancement(id);
+    }
+
+    public Iterable<Advancement> getAdvancements()
+    {
+        return ADVANCEMENT_LIST.getAdvancements();
+    }
+}

build/tmp/recompileMc/sources/net/minecraft/advancements/AdvancementProgress.java

@@ -0,0 +1,345 @@
+package net.minecraft.advancements;
+
+import com.google.common.collect.Lists;
+import com.google.common.collect.Maps;
+import com.google.gson.JsonDeserializationContext;
+import com.google.gson.JsonDeserializer;
+import com.google.gson.JsonElement;
+import com.google.gson.JsonObject;
+import com.google.gson.JsonParseException;
+import com.google.gson.JsonSerializationContext;
+import com.google.gson.JsonSerializer;
+import java.lang.reflect.Type;
+import java.util.Arrays;
+import java.util.Date;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.Map.Entry;
+import javax.annotation.Nullable;
+import net.minecraft.network.PacketBuffer;
+import net.minecraft.util.JsonUtils;
+import net.minecraftforge.fml.relauncher.Side;
+import net.minecraftforge.fml.relauncher.SideOnly;
+
+public class AdvancementProgress implements Comparable<AdvancementProgress>
+{
+    private final Map<String, CriterionProgress> criteria = Maps.<String, CriterionProgress>newHashMap();
+    private String[][] requirements = new String[0][];
+
+    /**
+     * Update this AdvancementProgress' criteria and requirements
+     */
+    public void update(Map<String, Criterion> criteriaIn, String[][] requirements)
+    {
+        Set<String> set = criteriaIn.keySet();
+        Iterator<Entry<String, CriterionProgress>> iterator = this.criteria.entrySet().iterator();
+
+        while (iterator.hasNext())
+        {
+            Entry<String, CriterionProgress> entry = (Entry)iterator.next();
+
+            if (!set.contains(entry.getKey()))
+            {
+                iterator.remove();
+            }
+        }
+
+        for (String s : set)
+        {
+            if (!this.criteria.containsKey(s))
+            {
+                this.criteria.put(s, new CriterionProgress(this));
+            }
+        }
+
+        this.requirements = requirements;
+    }
+
+    public boolean isDone()
+    {
+        if (this.requirements.length == 0)
+        {
+            return false;
+        }
+        else
+        {
+            for (String[] astring : this.requirements)
+            {
+                boolean flag = false;
+
+                for (String s : astring)
+                {
+                    CriterionProgress criterionprogress = this.getCriterionProgress(s);
+
+                    if (criterionprogress != null && criterionprogress.isObtained())
+                    {
+                        flag = true;
+                        break;
+                    }
+                }
+
+                if (!flag)
+                {
+                    return false;
+                }
+            }
+
+            return true;
+        }
+    }
+
+    public boolean hasProgress()
+    {
+        for (CriterionProgress criterionprogress : this.criteria.values())
+        {
+            if (criterionprogress.isObtained())
+            {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    public boolean grantCriterion(String criterionIn)
+    {
+        CriterionProgress criterionprogress = this.criteria.get(criterionIn);
+
+        if (criterionprogress != null && !criterionprogress.isObtained())
+        {
+            criterionprogress.obtain();
+            return true;
+        }
+        else
+        {
+            return false;
+        }
+    }
+
+    public boolean revokeCriterion(String criterionIn)
+    {
+        CriterionProgress criterionprogress = this.criteria.get(criterionIn);
+
+        if (criterionprogress != null && criterionprogress.isObtained())
+        {
+            criterionprogress.reset();
+            return true;
+        }
+        else
+        {
+            return false;
+        }
+    }
+
+    public String toString()
+    {
+        return "AdvancementProgress{criteria=" + this.criteria + ", requirements=" + Arrays.deepToString(this.requirements) + '}';
+    }
+
+    public void serializeToNetwork(PacketBuffer p_192104_1_)
+    {
+        p_192104_1_.writeVarInt(this.criteria.size());
+
+        for (Entry<String, CriterionProgress> entry : this.criteria.entrySet())
+        {
+            p_192104_1_.writeString(entry.getKey());
+            ((CriterionProgress)entry.getValue()).write(p_192104_1_);
+        }
+    }
+
+    public static AdvancementProgress fromNetwork(PacketBuffer p_192100_0_)
+    {
+        AdvancementProgress advancementprogress = new AdvancementProgress();
+        int i = p_192100_0_.readVarInt();
+
+        for (int j = 0; j < i; ++j)
+        {
+            advancementprogress.criteria.put(p_192100_0_.readString(32767), CriterionProgress.read(p_192100_0_, advancementprogress));
+        }
+
+        return advancementprogress;
+    }
+
+    @Nullable
+    public CriterionProgress getCriterionProgress(String criterionIn)
+    {
+        return this.criteria.get(criterionIn);
+    }
+
+    @SideOnly(Side.CLIENT)
+    public float getPercent()
+    {
+        if (this.criteria.isEmpty())
+        {
+            return 0.0F;
+        }
+        else
+        {
+            float f = (float)this.requirements.length;
+            float f1 = (float)this.countCompletedRequirements();
+            return f1 / f;
+        }
+    }
+
+    @Nullable
+    @SideOnly(Side.CLIENT)
+    public String getProgressText()
+    {
+        if (this.criteria.isEmpty())
+        {
+            return null;
+        }
+        else
+        {
+            int i = this.requirements.length;
+
+            if (i <= 1)
+            {
+                return null;
+            }
+            else
+            {
+                int j = this.countCompletedRequirements();
+                return j + "/" + i;
+            }
+        }
+    }
+
+    @SideOnly(Side.CLIENT)
+    private int countCompletedRequirements()
+    {
+        int i = 0;
+
+        for (String[] astring : this.requirements)
+        {
+            boolean flag = false;
+
+            for (String s : astring)
+            {
+                CriterionProgress criterionprogress = this.getCriterionProgress(s);
+
+                if (criterionprogress != null && criterionprogress.isObtained())
+                {
+                    flag = true;
+                    break;
+                }
+            }
+
+            if (flag)
+            {
+                ++i;
+            }
+        }
+
+        return i;
+    }
+
+    public Iterable<String> getRemaningCriteria()
+    {
+        List<String> list = Lists.<String>newArrayList();
+
+        for (Entry<String, CriterionProgress> entry : this.criteria.entrySet())
+        {
+            if (!((CriterionProgress)entry.getValue()).isObtained())
+            {
+                list.add(entry.getKey());
+            }
+        }
+
+        return list;
+    }
+
+    public Iterable<String> getCompletedCriteria()
+    {
+        List<String> list = Lists.<String>newArrayList();
+
+        for (Entry<String, CriterionProgress> entry : this.criteria.entrySet())
+        {
+            if (((CriterionProgress)entry.getValue()).isObtained())
+            {
+                list.add(entry.getKey());
+            }
+        }
+
+        return list;
+    }
+
+    @Nullable
+    public Date getFirstProgressDate()
+    {
+        Date date = null;
+
+        for (CriterionProgress criterionprogress : this.criteria.values())
+        {
+            if (criterionprogress.isObtained() && (date == null || criterionprogress.getObtained().before(date)))
+            {
+                date = criterionprogress.getObtained();
+            }
+        }
+
+        return date;
+    }
+
+    public int compareTo(AdvancementProgress p_compareTo_1_)
+    {
+        Date date = this.getFirstProgressDate();
+        Date date1 = p_compareTo_1_.getFirstProgressDate();
+
+        if (date == null && date1 != null)
+        {
+            return 1;
+        }
+        else if (date != null && date1 == null)
+        {
+            return -1;
+        }
+        else
+        {
+            return date == null && date1 == null ? 0 : date.compareTo(date1);
+        }
+    }
+
+    public static class Serializer implements JsonDeserializer<AdvancementProgress>, JsonSerializer<AdvancementProgress>
+        {
+            public JsonElement serialize(AdvancementProgress p_serialize_1_, Type p_serialize_2_, JsonSerializationContext p_serialize_3_)
+            {
+                JsonObject jsonobject = new JsonObject();
+                JsonObject jsonobject1 = new JsonObject();
+
+                for (Entry<String, CriterionProgress> entry : p_serialize_1_.criteria.entrySet())
+                {
+                    CriterionProgress criterionprogress = entry.getValue();
+
+                    if (criterionprogress.isObtained())
+                    {
+                        jsonobject1.add(entry.getKey(), criterionprogress.serialize());
+                    }
+                }
+
+                if (!jsonobject1.entrySet().isEmpty())
+                {
+                    jsonobject.add("criteria", jsonobject1);
+                }
+
+                jsonobject.addProperty("done", Boolean.valueOf(p_serialize_1_.isDone()));
+                return jsonobject;
+            }
+
+            public AdvancementProgress deserialize(JsonElement p_deserialize_1_, Type p_deserialize_2_, JsonDeserializationContext p_deserialize_3_) throws JsonParseException
+            {
+                JsonObject jsonobject = JsonUtils.getJsonObject(p_deserialize_1_, "advancement");
+                JsonObject jsonobject1 = JsonUtils.getJsonObject(jsonobject, "criteria", new JsonObject());
+                AdvancementProgress advancementprogress = new AdvancementProgress();
+
+                for (Entry<String, JsonElement> entry : jsonobject1.entrySet())
+                {
+                    String s = entry.getKey();
+                    advancementprogress.criteria.put(s, CriterionProgress.fromDateTime(advancementprogress, JsonUtils.getString(entry.getValue(), s)));
+                }
+
+                return advancementprogress;
+            }
+        }
+}

build/tmp/recompileMc/sources/net/minecraft/advancements/AdvancementRewards.java

@@ -0,0 +1,222 @@
+package net.minecraft.advancements;
+
+import com.google.gson.JsonArray;
+import com.google.gson.JsonDeserializationContext;
+import com.google.gson.JsonDeserializer;
+import com.google.gson.JsonElement;
+import com.google.gson.JsonObject;
+import com.google.gson.JsonParseException;
+import com.google.gson.JsonSyntaxException;
+import java.lang.reflect.Type;
+import java.util.Arrays;
+import net.minecraft.command.CommandResultStats;
+import net.minecraft.command.FunctionObject;
+import net.minecraft.command.ICommandSender;
+import net.minecraft.entity.Entity;
+import net.minecraft.entity.item.EntityItem;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.entity.player.EntityPlayerMP;
+import net.minecraft.init.SoundEvents;
+import net.minecraft.item.ItemStack;
+import net.minecraft.item.crafting.CraftingManager;
+import net.minecraft.item.crafting.IRecipe;
+import net.minecraft.server.MinecraftServer;
+import net.minecraft.util.JsonUtils;
+import net.minecraft.util.ResourceLocation;
+import net.minecraft.util.SoundCategory;
+import net.minecraft.util.math.BlockPos;
+import net.minecraft.util.math.Vec3d;
+import net.minecraft.util.text.ITextComponent;
+import net.minecraft.world.World;
+import net.minecraft.world.storage.loot.LootContext;
+
+public class AdvancementRewards
+{
+    public static final AdvancementRewards EMPTY = new AdvancementRewards(0, new ResourceLocation[0], new ResourceLocation[0], FunctionObject.CacheableFunction.EMPTY);
+    private final int experience;
+    private final ResourceLocation[] loot;
+    private final ResourceLocation[] recipes;
+    private final FunctionObject.CacheableFunction function;
+
+    public AdvancementRewards(int experience, ResourceLocation[] loot, ResourceLocation[] recipes, FunctionObject.CacheableFunction function)
+    {
+        this.experience = experience;
+        this.loot = loot;
+        this.recipes = recipes;
+        this.function = function;
+    }
+
+    public void apply(final EntityPlayerMP player)
+    {
+        player.addExperience(this.experience);
+        LootContext lootcontext = (new LootContext.Builder(player.getServerWorld())).withLootedEntity(player).withPlayer(player).withLuck(player.getLuck()).build(); // Forge: add player & luck to LootContext
+        boolean flag = false;
+
+        for (ResourceLocation resourcelocation : this.loot)
+        {
+            for (ItemStack itemstack : player.world.getLootTableManager().getLootTableFromLocation(resourcelocation).generateLootForPools(player.getRNG(), lootcontext))
+            {
+                if (player.addItemStackToInventory(itemstack))
+                {
+                    player.world.playSound((EntityPlayer)null, player.posX, player.posY, player.posZ, SoundEvents.ENTITY_ITEM_PICKUP, SoundCategory.PLAYERS, 0.2F, ((player.getRNG().nextFloat() - player.getRNG().nextFloat()) * 0.7F + 1.0F) * 2.0F);
+                    flag = true;
+                }
+                else
+                {
+                    EntityItem entityitem = player.dropItem(itemstack, false);
+
+                    if (entityitem != null)
+                    {
+                        entityitem.setNoPickupDelay();
+                        entityitem.setOwner(player.getName());
+                    }
+                }
+            }
+        }
+
+        if (flag)
+        {
+            player.inventoryContainer.detectAndSendChanges();
+        }
+
+        if (this.recipes.length > 0)
+        {
+            player.unlockRecipes(this.recipes);
+        }
+
+        final MinecraftServer minecraftserver = player.mcServer;
+        FunctionObject functionobject = this.function.get(minecraftserver.getFunctionManager());
+
+        if (functionobject != null)
+        {
+            ICommandSender icommandsender = new ICommandSender()
+            {
+                /**
+                 * Get the name of this object. For players this returns their username
+                 */
+                public String getName()
+                {
+                    return player.getName();
+                }
+                /**
+                 * Get the formatted ChatComponent that will be used for the sender's username in chat
+                 */
+                public ITextComponent getDisplayName()
+                {
+                    return player.getDisplayName();
+                }
+                /**
+                 * Send a chat message to the CommandSender
+                 */
+                public void sendMessage(ITextComponent component)
+                {
+                }
+                /**
+                 * Returns {@code true} if the CommandSender is allowed to execute the command, {@code false} if not
+                 */
+                public boolean canUseCommand(int permLevel, String commandName)
+                {
+                    return permLevel <= 2;
+                }
+                /**
+                 * Get the position in the world. <b>{@code null} is not allowed!</b> If you are not an entity in the
+                 * world, return the coordinates 0, 0, 0
+                 */
+                public BlockPos getPosition()
+                {
+                    return player.getPosition();
+                }
+                /**
+                 * Get the position vector. <b>{@code null} is not allowed!</b> If you are not an entity in the world,
+                 * return 0.0D, 0.0D, 0.0D
+                 */
+                public Vec3d getPositionVector()
+                {
+                    return player.getPositionVector();
+                }
+                /**
+                 * Get the world, if available. <b>{@code null} is not allowed!</b> If you are not an entity in the
+                 * world, return the overworld
+                 */
+                public World getEntityWorld()
+                {
+                    return player.world;
+                }
+                /**
+                 * Returns the entity associated with the command sender. MAY BE NULL!
+                 */
+                public Entity getCommandSenderEntity()
+                {
+                    return player;
+                }
+                /**
+                 * Returns true if the command sender should be sent feedback about executed commands
+                 */
+                public boolean sendCommandFeedback()
+                {
+                    return minecraftserver.worlds[0].getGameRules().getBoolean("commandBlockOutput");
+                }
+                public void setCommandStat(CommandResultStats.Type type, int amount)
+                {
+                    player.setCommandStat(type, amount);
+                }
+                /**
+                 * Get the Minecraft server instance
+                 */
+                public MinecraftServer getServer()
+                {
+                    return player.getServer();
+                }
+            };
+            minecraftserver.getFunctionManager().execute(functionobject, icommandsender);
+        }
+    }
+
+    public String toString()
+    {
+        return "AdvancementRewards{experience=" + this.experience + ", loot=" + Arrays.toString((Object[])this.loot) + ", recipes=" + Arrays.toString((Object[])this.recipes) + ", function=" + this.function + '}';
+    }
+
+    public static class Deserializer implements JsonDeserializer<AdvancementRewards>
+        {
+            public AdvancementRewards deserialize(JsonElement p_deserialize_1_, Type p_deserialize_2_, JsonDeserializationContext p_deserialize_3_) throws JsonParseException
+            {
+                JsonObject jsonobject = JsonUtils.getJsonObject(p_deserialize_1_, "rewards");
+                int i = JsonUtils.getInt(jsonobject, "experience", 0);
+                JsonArray jsonarray = JsonUtils.getJsonArray(jsonobject, "loot", new JsonArray());
+                ResourceLocation[] aresourcelocation = new ResourceLocation[jsonarray.size()];
+
+                for (int j = 0; j < aresourcelocation.length; ++j)
+                {
+                    aresourcelocation[j] = new ResourceLocation(JsonUtils.getString(jsonarray.get(j), "loot[" + j + "]"));
+                }
+
+                JsonArray jsonarray1 = JsonUtils.getJsonArray(jsonobject, "recipes", new JsonArray());
+                ResourceLocation[] aresourcelocation1 = new ResourceLocation[jsonarray1.size()];
+
+                for (int k = 0; k < aresourcelocation1.length; ++k)
+                {
+                    aresourcelocation1[k] = new ResourceLocation(JsonUtils.getString(jsonarray1.get(k), "recipes[" + k + "]"));
+                    IRecipe irecipe = CraftingManager.getRecipe(aresourcelocation1[k]);
+
+                    if (irecipe == null)
+                    {
+                        throw new JsonSyntaxException("Unknown recipe '" + aresourcelocation1[k] + "'");
+                    }
+                }
+
+                FunctionObject.CacheableFunction functionobject$cacheablefunction;
+
+                if (jsonobject.has("function"))
+                {
+                    functionobject$cacheablefunction = new FunctionObject.CacheableFunction(new ResourceLocation(JsonUtils.getString(jsonobject, "function")));
+                }
+                else
+                {
+                    functionobject$cacheablefunction = FunctionObject.CacheableFunction.EMPTY;
+                }
+
+                return new AdvancementRewards(i, aresourcelocation, aresourcelocation1, functionobject$cacheablefunction);
+            }
+        }
+}

build/tmp/recompileMc/sources/net/minecraft/advancements/AdvancementTreeNode.java

@@ -0,0 +1,286 @@
+package net.minecraft.advancements;
+
+import com.google.common.collect.Lists;
+import java.util.List;
+import javax.annotation.Nullable;
+
+public class AdvancementTreeNode
+{
+    private final Advancement advancement;
+    private final AdvancementTreeNode parent;
+    private final AdvancementTreeNode sibling;
+    private final int index;
+    private final List<AdvancementTreeNode> children = Lists.<AdvancementTreeNode>newArrayList();
+    private AdvancementTreeNode ancestor;
+    private AdvancementTreeNode thread;
+    private int x;
+    private float y;
+    private float mod;
+    private float change;
+    private float shift;
+
+    public AdvancementTreeNode(Advancement advancementIn, @Nullable AdvancementTreeNode parentIn, @Nullable AdvancementTreeNode siblingIn, int indexIn, int xIn)
+    {
+        if (advancementIn.getDisplay() == null)
+        {
+            throw new IllegalArgumentException("Can't position an invisible advancement!");
+        }
+        else
+        {
+            this.advancement = advancementIn;
+            this.parent = parentIn;
+            this.sibling = siblingIn;
+            this.index = indexIn;
+            this.ancestor = this;
+            this.x = xIn;
+            this.y = -1.0F;
+            AdvancementTreeNode advancementtreenode = null;
+
+            for (Advancement advancement : advancementIn.getChildren())
+            {
+                advancementtreenode = this.buildSubTree(advancement, advancementtreenode);
+            }
+        }
+    }
+
+    @Nullable
+    private AdvancementTreeNode buildSubTree(Advancement advancementIn, @Nullable AdvancementTreeNode previous)
+    {
+        if (advancementIn.getDisplay() != null)
+        {
+            previous = new AdvancementTreeNode(advancementIn, this, previous, this.children.size() + 1, this.x + 1);
+            this.children.add(previous);
+        }
+        else
+        {
+            for (Advancement advancement : advancementIn.getChildren())
+            {
+                previous = this.buildSubTree(advancement, previous);
+            }
+        }
+
+        return previous;
+    }
+
+    private void firstWalk()
+    {
+        if (this.children.isEmpty())
+        {
+            if (this.sibling != null)
+            {
+                this.y = this.sibling.y + 1.0F;
+            }
+            else
+            {
+                this.y = 0.0F;
+            }
+        }
+        else
+        {
+            AdvancementTreeNode advancementtreenode = null;
+
+            for (AdvancementTreeNode advancementtreenode1 : this.children)
+            {
+                advancementtreenode1.firstWalk();
+                advancementtreenode = advancementtreenode1.apportion(advancementtreenode == null ? advancementtreenode1 : advancementtreenode);
+            }
+
+            this.executeShifts();
+            float f = ((this.children.get(0)).y + (this.children.get(this.children.size() - 1)).y) / 2.0F;
+
+            if (this.sibling != null)
+            {
+                this.y = this.sibling.y + 1.0F;
+                this.mod = this.y - f;
+            }
+            else
+            {
+                this.y = f;
+            }
+        }
+    }
+
+    private float secondWalk(float p_192319_1_, int p_192319_2_, float p_192319_3_)
+    {
+        this.y += p_192319_1_;
+        this.x = p_192319_2_;
+
+        if (this.y < p_192319_3_)
+        {
+            p_192319_3_ = this.y;
+        }
+
+        for (AdvancementTreeNode advancementtreenode : this.children)
+        {
+            p_192319_3_ = advancementtreenode.secondWalk(p_192319_1_ + this.mod, p_192319_2_ + 1, p_192319_3_);
+        }
+
+        return p_192319_3_;
+    }
+
+    private void thirdWalk(float yIn)
+    {
+        this.y += yIn;
+
+        for (AdvancementTreeNode advancementtreenode : this.children)
+        {
+            advancementtreenode.thirdWalk(yIn);
+        }
+    }
+
+    private void executeShifts()
+    {
+        float f = 0.0F;
+        float f1 = 0.0F;
+
+        for (int i = this.children.size() - 1; i >= 0; --i)
+        {
+            AdvancementTreeNode advancementtreenode = this.children.get(i);
+            advancementtreenode.y += f;
+            advancementtreenode.mod += f;
+            f1 += advancementtreenode.change;
+            f += advancementtreenode.shift + f1;
+        }
+    }
+
+    @Nullable
+    private AdvancementTreeNode getFirstChild()
+    {
+        if (this.thread != null)
+        {
+            return this.thread;
+        }
+        else
+        {
+            return !this.children.isEmpty() ? (AdvancementTreeNode)this.children.get(0) : null;
+        }
+    }
+
+    @Nullable
+    private AdvancementTreeNode getLastChild()
+    {
+        if (this.thread != null)
+        {
+            return this.thread;
+        }
+        else
+        {
+            return !this.children.isEmpty() ? (AdvancementTreeNode)this.children.get(this.children.size() - 1) : null;
+        }
+    }
+
+    private AdvancementTreeNode apportion(AdvancementTreeNode nodeIn)
+    {
+        if (this.sibling == null)
+        {
+            return nodeIn;
+        }
+        else
+        {
+            AdvancementTreeNode advancementtreenode = this;
+            AdvancementTreeNode advancementtreenode1 = this;
+            AdvancementTreeNode advancementtreenode2 = this.sibling;
+            AdvancementTreeNode advancementtreenode3 = this.parent.children.get(0);
+            float f = this.mod;
+            float f1 = this.mod;
+            float f2 = advancementtreenode2.mod;
+            float f3;
+
+            for (f3 = advancementtreenode3.mod; advancementtreenode2.getLastChild() != null && advancementtreenode.getFirstChild() != null; f1 += advancementtreenode1.mod)
+            {
+                advancementtreenode2 = advancementtreenode2.getLastChild();
+                advancementtreenode = advancementtreenode.getFirstChild();
+                advancementtreenode3 = advancementtreenode3.getFirstChild();
+                advancementtreenode1 = advancementtreenode1.getLastChild();
+                advancementtreenode1.ancestor = this;
+                float f4 = advancementtreenode2.y + f2 - (advancementtreenode.y + f) + 1.0F;
+
+                if (f4 > 0.0F)
+                {
+                    advancementtreenode2.getAncestor(this, nodeIn).moveSubtree(this, f4);
+                    f += f4;
+                    f1 += f4;
+                }
+
+                f2 += advancementtreenode2.mod;
+                f += advancementtreenode.mod;
+                f3 += advancementtreenode3.mod;
+            }
+
+            if (advancementtreenode2.getLastChild() != null && advancementtreenode1.getLastChild() == null)
+            {
+                advancementtreenode1.thread = advancementtreenode2.getLastChild();
+                advancementtreenode1.mod += f2 - f1;
+            }
+            else
+            {
+                if (advancementtreenode.getFirstChild() != null && advancementtreenode3.getFirstChild() == null)
+                {
+                    advancementtreenode3.thread = advancementtreenode.getFirstChild();
+                    advancementtreenode3.mod += f - f3;
+                }
+
+                nodeIn = this;
+            }
+
+            return nodeIn;
+        }
+    }
+
+    private void moveSubtree(AdvancementTreeNode nodeIn, float p_192316_2_)
+    {
+        float f = (float)(nodeIn.index - this.index);
+
+        if (f != 0.0F)
+        {
+            nodeIn.change -= p_192316_2_ / f;
+            this.change += p_192316_2_ / f;
+        }
+
+        nodeIn.shift += p_192316_2_;
+        nodeIn.y += p_192316_2_;
+        nodeIn.mod += p_192316_2_;
+    }
+
+    private AdvancementTreeNode getAncestor(AdvancementTreeNode p_192326_1_, AdvancementTreeNode p_192326_2_)
+    {
+        return this.ancestor != null && p_192326_1_.parent.children.contains(this.ancestor) ? this.ancestor : p_192326_2_;
+    }
+
+    private void updatePosition()
+    {
+        if (this.advancement.getDisplay() != null)
+        {
+            this.advancement.getDisplay().setPosition((float)this.x, this.y);
+        }
+
+        if (!this.children.isEmpty())
+        {
+            for (AdvancementTreeNode advancementtreenode : this.children)
+            {
+                advancementtreenode.updatePosition();
+            }
+        }
+    }
+
+    public static void layout(Advancement root)
+    {
+        if (root.getDisplay() == null)
+        {
+            throw new IllegalArgumentException("Can't position children of an invisible root!");
+        }
+        else
+        {
+            AdvancementTreeNode advancementtreenode = new AdvancementTreeNode(root, (AdvancementTreeNode)null, (AdvancementTreeNode)null, 1, 0);
+            advancementtreenode.firstWalk();
+            float f = advancementtreenode.secondWalk(0.0F, 0, advancementtreenode.y);
+
+            if (f < 0.0F)
+            {
+                advancementtreenode.thirdWalk(-f);
+            }
+
+            advancementtreenode.updatePosition();
+        }
+    }
+}

build/tmp/recompileMc/sources/net/minecraft/advancements/CriteriaTriggers.java

@@ -0,0 +1,89 @@
+package net.minecraft.advancements;
+
+import com.google.common.collect.Maps;
+import java.util.Map;
+import javax.annotation.Nullable;
+import net.minecraft.advancements.critereon.BredAnimalsTrigger;
+import net.minecraft.advancements.critereon.BrewedPotionTrigger;
+import net.minecraft.advancements.critereon.ChangeDimensionTrigger;
+import net.minecraft.advancements.critereon.ConstructBeaconTrigger;
+import net.minecraft.advancements.critereon.ConsumeItemTrigger;
+import net.minecraft.advancements.critereon.CuredZombieVillagerTrigger;
+import net.minecraft.advancements.critereon.EffectsChangedTrigger;
+import net.minecraft.advancements.critereon.EnchantedItemTrigger;
+import net.minecraft.advancements.critereon.EnterBlockTrigger;
+import net.minecraft.advancements.critereon.EntityHurtPlayerTrigger;
+import net.minecraft.advancements.critereon.ImpossibleTrigger;
+import net.minecraft.advancements.critereon.InventoryChangeTrigger;
+import net.minecraft.advancements.critereon.ItemDurabilityTrigger;
+import net.minecraft.advancements.critereon.KilledTrigger;
+import net.minecraft.advancements.critereon.LevitationTrigger;
+import net.minecraft.advancements.critereon.NetherTravelTrigger;
+import net.minecraft.advancements.critereon.PlacedBlockTrigger;
+import net.minecraft.advancements.critereon.PlayerHurtEntityTrigger;
+import net.minecraft.advancements.critereon.PositionTrigger;
+import net.minecraft.advancements.critereon.RecipeUnlockedTrigger;
+import net.minecraft.advancements.critereon.SummonedEntityTrigger;
+import net.minecraft.advancements.critereon.TameAnimalTrigger;
+import net.minecraft.advancements.critereon.TickTrigger;
+import net.minecraft.advancements.critereon.UsedEnderEyeTrigger;
+import net.minecraft.advancements.critereon.UsedTotemTrigger;
+import net.minecraft.advancements.critereon.VillagerTradeTrigger;
+import net.minecraft.util.ResourceLocation;
+
+public class CriteriaTriggers
+{
+    private static final Map < ResourceLocation, ICriterionTrigger<? >> REGISTRY = Maps. < ResourceLocation, ICriterionTrigger<? >> newHashMap();
+    public static final ImpossibleTrigger IMPOSSIBLE = (ImpossibleTrigger)register(new ImpossibleTrigger());
+    public static final KilledTrigger PLAYER_KILLED_ENTITY = (KilledTrigger)register(new KilledTrigger(new ResourceLocation("player_killed_entity")));
+    public static final KilledTrigger ENTITY_KILLED_PLAYER = (KilledTrigger)register(new KilledTrigger(new ResourceLocation("entity_killed_player")));
+    public static final EnterBlockTrigger ENTER_BLOCK = (EnterBlockTrigger)register(new EnterBlockTrigger());
+    public static final InventoryChangeTrigger INVENTORY_CHANGED = (InventoryChangeTrigger)register(new InventoryChangeTrigger());
+    public static final RecipeUnlockedTrigger RECIPE_UNLOCKED = (RecipeUnlockedTrigger)register(new RecipeUnlockedTrigger());
+    public static final PlayerHurtEntityTrigger PLAYER_HURT_ENTITY = (PlayerHurtEntityTrigger)register(new PlayerHurtEntityTrigger());
+    public static final EntityHurtPlayerTrigger ENTITY_HURT_PLAYER = (EntityHurtPlayerTrigger)register(new EntityHurtPlayerTrigger());
+    public static final EnchantedItemTrigger ENCHANTED_ITEM = (EnchantedItemTrigger)register(new EnchantedItemTrigger());
+    public static final BrewedPotionTrigger BREWED_POTION = (BrewedPotionTrigger)register(new BrewedPotionTrigger());
+    public static final ConstructBeaconTrigger CONSTRUCT_BEACON = (ConstructBeaconTrigger)register(new ConstructBeaconTrigger());
+    public static final UsedEnderEyeTrigger USED_ENDER_EYE = (UsedEnderEyeTrigger)register(new UsedEnderEyeTrigger());
+    public static final SummonedEntityTrigger SUMMONED_ENTITY = (SummonedEntityTrigger)register(new SummonedEntityTrigger());
+    public static final BredAnimalsTrigger BRED_ANIMALS = (BredAnimalsTrigger)register(new BredAnimalsTrigger());
+    public static final PositionTrigger LOCATION = (PositionTrigger)register(new PositionTrigger(new ResourceLocation("location")));
+    public static final PositionTrigger SLEPT_IN_BED = (PositionTrigger)register(new PositionTrigger(new ResourceLocation("slept_in_bed")));
+    public static final CuredZombieVillagerTrigger CURED_ZOMBIE_VILLAGER = (CuredZombieVillagerTrigger)register(new CuredZombieVillagerTrigger());
+    public static final VillagerTradeTrigger VILLAGER_TRADE = (VillagerTradeTrigger)register(new VillagerTradeTrigger());
+    public static final ItemDurabilityTrigger ITEM_DURABILITY_CHANGED = (ItemDurabilityTrigger)register(new ItemDurabilityTrigger());
+    public static final LevitationTrigger LEVITATION = (LevitationTrigger)register(new LevitationTrigger());
+    public static final ChangeDimensionTrigger CHANGED_DIMENSION = (ChangeDimensionTrigger)register(new ChangeDimensionTrigger());
+    public static final TickTrigger TICK = (TickTrigger)register(new TickTrigger());
+    public static final TameAnimalTrigger TAME_ANIMAL = (TameAnimalTrigger)register(new TameAnimalTrigger());
+    public static final PlacedBlockTrigger PLACED_BLOCK = (PlacedBlockTrigger)register(new PlacedBlockTrigger());
+    public static final ConsumeItemTrigger CONSUME_ITEM = (ConsumeItemTrigger)register(new ConsumeItemTrigger());
+    public static final EffectsChangedTrigger EFFECTS_CHANGED = (EffectsChangedTrigger)register(new EffectsChangedTrigger());
+    public static final UsedTotemTrigger USED_TOTEM = (UsedTotemTrigger)register(new UsedTotemTrigger());
+    public static final NetherTravelTrigger NETHER_TRAVEL = (NetherTravelTrigger)register(new NetherTravelTrigger());
+
+    public static <T extends ICriterionTrigger> T register(T criterion)
+    {
+        if (REGISTRY.containsKey(criterion.getId()))
+        {
+            throw new IllegalArgumentException("Duplicate criterion id " + criterion.getId());
+        }
+        else
+        {
+            REGISTRY.put(criterion.getId(), criterion);
+            return criterion;
+        }
+    }
+
+    @Nullable
+    public static <T extends ICriterionInstance> ICriterionTrigger<T> get(ResourceLocation id)
+    {
+        return (ICriterionTrigger)REGISTRY.get(id);
+    }
+
+    public static Iterable <? extends ICriterionTrigger<? >> getAll()
+    {
+        return REGISTRY.values();
+    }
+}

build/tmp/recompileMc/sources/net/minecraft/advancements/Criterion.java

@@ -0,0 +1,134 @@
+package net.minecraft.advancements;
+
+import com.google.common.collect.Maps;
+import com.google.gson.JsonDeserializationContext;
+import com.google.gson.JsonElement;
+import com.google.gson.JsonObject;
+import com.google.gson.JsonSyntaxException;
+import java.util.Map;
+import java.util.Map.Entry;
+import javax.annotation.Nullable;
+import net.minecraft.network.PacketBuffer;
+import net.minecraft.util.JsonUtils;
+import net.minecraft.util.ResourceLocation;
+
+public class Criterion
+{
+    private final ICriterionInstance criterionInstance;
+
+    public Criterion(ICriterionInstance p_i47470_1_)
+    {
+        this.criterionInstance = p_i47470_1_;
+    }
+
+    public Criterion()
+    {
+        this.criterionInstance = null;
+    }
+
+    public void serializeToNetwork(PacketBuffer p_192140_1_)
+    {
+    }
+
+    /**
+     * Deserialize a <em>single</em> {@code Criterion} from {@code json}. The {@link ICriterionTrigger} is chosen by the
+     * {@code "trigger"} property of the object, which can then handle the optional {@code "conditions"} in the object.
+     * The {@code "conditions"}, if present, must be a {@code JsonObject}. The resulting {@link ICriterionInstance} is
+     * wrapped in a {@code Criterion}.
+     * 
+     * @return the deserialized {@code Criterion}.
+     * @see ICriterionTrigger#deserializeInstance(JsonObject, JsonDeserializationContext)
+     *  
+     * @param json the {@code JsonObject} to deserialize from
+     * @param context the {@code JsonDeserializationContext} to deserialize in
+     */
+    public static Criterion criterionFromJson(JsonObject json, JsonDeserializationContext context)
+    {
+        ResourceLocation resourcelocation = new ResourceLocation(JsonUtils.getString(json, "trigger"));
+        ICriterionTrigger<?> icriteriontrigger = CriteriaTriggers.get(resourcelocation);
+
+        if (icriteriontrigger == null)
+        {
+            throw new JsonSyntaxException("Invalid criterion trigger: " + resourcelocation);
+        }
+        else
+        {
+            ICriterionInstance icriterioninstance = icriteriontrigger.deserializeInstance(JsonUtils.getJsonObject(json, "conditions", new JsonObject()), context);
+            return new Criterion(icriterioninstance);
+        }
+    }
+
+    public static Criterion criterionFromNetwork(PacketBuffer p_192146_0_)
+    {
+        return new Criterion();
+    }
+
+    /**
+     * Read criteria from {@code json}. The keys of the object name the criteria, and the values (which must be objects)
+     * are the criteria themselves.
+     * 
+     * @return the deserialized criteria. Each key-value pair consists of a {@code Criterion} and its name.
+     * @see #criterionFromJson(JsonObject, JsonDeserializationContext)
+     *  
+     * @param json the {@code JsonObject} to deserialize from
+     * @param context the {@code JsonDeserializationContext} to deserialize in
+     */
+    public static Map<String, Criterion> criteriaFromJson(JsonObject json, JsonDeserializationContext context)
+    {
+        Map<String, Criterion> map = Maps.<String, Criterion>newHashMap();
+
+        for (Entry<String, JsonElement> entry : json.entrySet())
+        {
+            map.put(entry.getKey(), criterionFromJson(JsonUtils.getJsonObject(entry.getValue(), "criterion"), context));
+        }
+
+        return map;
+    }
+
+    /**
+     * Read criteria from {@code buf}.
+     * 
+     * @return the read criteria. Each key-value pair consists of a {@code Criterion} and its name.
+     * @see #serializeToNetwork(Map, PacketBuffer)
+     *  
+     * @param bus the {@code PacketBuffer} to read from
+     */
+    public static Map<String, Criterion> criteriaFromNetwork(PacketBuffer bus)
+    {
+        Map<String, Criterion> map = Maps.<String, Criterion>newHashMap();
+        int i = bus.readVarInt();
+
+        for (int j = 0; j < i; ++j)
+        {
+            map.put(bus.readString(32767), criterionFromNetwork(bus));
+        }
+
+        return map;
+    }
+
+    /**
+     * Write {@code criteria} to {@code buf}.
+     * 
+     * @see #criteriaFromNetwork(PacketBuffer)
+     *  
+     * @param criteria the criteria to write to {@code buf}. Each key-value pair consists of a {@code Criterion} and its
+     * name.
+     * @param buf the {@code PacketBuffer} to write to
+     */
+    public static void serializeToNetwork(Map<String, Criterion> criteria, PacketBuffer buf)
+    {
+        buf.writeVarInt(criteria.size());
+
+        for (Entry<String, Criterion> entry : criteria.entrySet())
+        {
+            buf.writeString(entry.getKey());
+            ((Criterion)entry.getValue()).serializeToNetwork(buf);
+        }
+    }
+
+    @Nullable
+    public ICriterionInstance getCriterionInstance()
+    {
+        return this.criterionInstance;
+    }
+}

build/tmp/recompileMc/sources/net/minecraft/advancements/CriterionProgress.java

@@ -0,0 +1,89 @@
+package net.minecraft.advancements;
+
+import com.google.gson.JsonElement;
+import com.google.gson.JsonNull;
+import com.google.gson.JsonPrimitive;
+import com.google.gson.JsonSyntaxException;
+import java.text.ParseException;
+import java.text.SimpleDateFormat;
+import java.util.Date;
+import net.minecraft.network.PacketBuffer;
+
+public class CriterionProgress
+{
+    private static final SimpleDateFormat DATE_TIME_FORMATTER = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss Z");
+    private final AdvancementProgress advancementProgress;
+    private Date obtained;
+
+    public CriterionProgress(AdvancementProgress advancementProgressIn)
+    {
+        this.advancementProgress = advancementProgressIn;
+    }
+
+    public boolean isObtained()
+    {
+        return this.obtained != null;
+    }
+
+    public void obtain()
+    {
+        this.obtained = new Date();
+    }
+
+    public void reset()
+    {
+        this.obtained = null;
+    }
+
+    public Date getObtained()
+    {
+        return this.obtained;
+    }
+
+    public String toString()
+    {
+        return "CriterionProgress{obtained=" + (this.obtained == null ? "false" : this.obtained) + '}';
+    }
+
+    public void write(PacketBuffer buf)
+    {
+        buf.writeBoolean(this.obtained != null);
+
+        if (this.obtained != null)
+        {
+            buf.writeTime(this.obtained);
+        }
+    }
+
+    public JsonElement serialize()
+    {
+        return (JsonElement)(this.obtained != null ? new JsonPrimitive(DATE_TIME_FORMATTER.format(this.obtained)) : JsonNull.INSTANCE);
+    }
+
+    public static CriterionProgress read(PacketBuffer buf, AdvancementProgress advancementProgressIn)
+    {
+        CriterionProgress criterionprogress = new CriterionProgress(advancementProgressIn);
+
+        if (buf.readBoolean())
+        {
+            criterionprogress.obtained = buf.readTime();
+        }
+
+        return criterionprogress;
+    }
+
+    public static CriterionProgress fromDateTime(AdvancementProgress advancementProgressIn, String dateTime)
+    {
+        CriterionProgress criterionprogress = new CriterionProgress(advancementProgressIn);
+
+        try
+        {
+            criterionprogress.obtained = DATE_TIME_FORMATTER.parse(dateTime);
+            return criterionprogress;
+        }
+        catch (ParseException parseexception)
+        {
+            throw new JsonSyntaxException("Invalid datetime: " + dateTime, parseexception);
+        }
+    }
+}

build/tmp/recompileMc/sources/net/minecraft/advancements/DisplayInfo.java

@@ -0,0 +1,189 @@
+package net.minecraft.advancements;
+
+import com.google.gson.JsonDeserializationContext;
+import com.google.gson.JsonObject;
+import com.google.gson.JsonSyntaxException;
+import java.io.IOException;
+import javax.annotation.Nullable;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+import net.minecraft.network.PacketBuffer;
+import net.minecraft.util.JsonUtils;
+import net.minecraft.util.ResourceLocation;
+import net.minecraft.util.text.ITextComponent;
+import net.minecraftforge.fml.relauncher.Side;
+import net.minecraftforge.fml.relauncher.SideOnly;
+
+public class DisplayInfo
+{
+    private final ITextComponent title;
+    private final ITextComponent description;
+    private final ItemStack icon;
+    private final ResourceLocation background;
+    private final FrameType frame;
+    private final boolean showToast;
+    private final boolean announceToChat;
+    private final boolean hidden;
+    private float x;
+    private float y;
+
+    public DisplayInfo(ItemStack icon, ITextComponent title, ITextComponent description, @Nullable ResourceLocation background, FrameType frame, boolean showToast, boolean announceToChat, boolean hidden)
+    {
+        this.title = title;
+        this.description = description;
+        this.icon = icon;
+        this.background = background;
+        this.frame = frame;
+        this.showToast = showToast;
+        this.announceToChat = announceToChat;
+        this.hidden = hidden;
+    }
+
+    public void setPosition(float x, float y)
+    {
+        this.x = x;
+        this.y = y;
+    }
+
+    public ITextComponent getTitle()
+    {
+        return this.title;
+    }
+
+    public ITextComponent getDescription()
+    {
+        return this.description;
+    }
+
+    @SideOnly(Side.CLIENT)
+    public ItemStack getIcon()
+    {
+        return this.icon;
+    }
+
+    @Nullable
+    @SideOnly(Side.CLIENT)
+    public ResourceLocation getBackground()
+    {
+        return this.background;
+    }
+
+    public FrameType getFrame()
+    {
+        return this.frame;
+    }
+
+    @SideOnly(Side.CLIENT)
+    public float getX()
+    {
+        return this.x;
+    }
+
+    @SideOnly(Side.CLIENT)
+    public float getY()
+    {
+        return this.y;
+    }
+
+    @SideOnly(Side.CLIENT)
+    public boolean shouldShowToast()
+    {
+        return this.showToast;
+    }
+
+    public boolean shouldAnnounceToChat()
+    {
+        return this.announceToChat;
+    }
+
+    public boolean isHidden()
+    {
+        return this.hidden;
+    }
+
+    public static DisplayInfo deserialize(JsonObject object, JsonDeserializationContext context)
+    {
+        ITextComponent itextcomponent = (ITextComponent)JsonUtils.deserializeClass(object, "title", context, ITextComponent.class);
+        ITextComponent itextcomponent1 = (ITextComponent)JsonUtils.deserializeClass(object, "description", context, ITextComponent.class);
+
+        if (itextcomponent != null && itextcomponent1 != null)
+        {
+            ItemStack itemstack = deserializeIcon(JsonUtils.getJsonObject(object, "icon"));
+            ResourceLocation resourcelocation = object.has("background") ? new ResourceLocation(JsonUtils.getString(object, "background")) : null;
+            FrameType frametype = object.has("frame") ? FrameType.byName(JsonUtils.getString(object, "frame")) : FrameType.TASK;
+            boolean flag = JsonUtils.getBoolean(object, "show_toast", true);
+            boolean flag1 = JsonUtils.getBoolean(object, "announce_to_chat", true);
+            boolean flag2 = JsonUtils.getBoolean(object, "hidden", false);
+            return new DisplayInfo(itemstack, itextcomponent, itextcomponent1, resourcelocation, frametype, flag, flag1, flag2);
+        }
+        else
+        {
+            throw new JsonSyntaxException("Both title and description must be set");
+        }
+    }
+
+    private static ItemStack deserializeIcon(JsonObject object)
+    {
+        if (!object.has("item"))
+        {
+            throw new JsonSyntaxException("Unsupported icon type, currently only items are supported (add 'item' key)");
+        }
+        else
+        {
+            Item item = JsonUtils.getItem(object, "item");
+            int i = JsonUtils.getInt(object, "data", 0);
+            ItemStack ret = new ItemStack(item, 1, i);
+            ret.setTagCompound(net.minecraftforge.common.util.JsonUtils.readNBT(object, "nbt"));
+            return ret;
+        }
+    }
+
+    public void write(PacketBuffer buf)
+    {
+        buf.writeTextComponent(this.title);
+        buf.writeTextComponent(this.description);
+        buf.writeItemStack(this.icon);
+        buf.writeEnumValue(this.frame);
+        int i = 0;
+
+        if (this.background != null)
+        {
+            i |= 1;
+        }
+
+        if (this.showToast)
+        {
+            i |= 2;
+        }
+
+        if (this.hidden)
+        {
+            i |= 4;
+        }
+
+        buf.writeInt(i);
+
+        if (this.background != null)
+        {
+            buf.writeResourceLocation(this.background);
+        }
+
+        buf.writeFloat(this.x);
+        buf.writeFloat(this.y);
+    }
+
+    public static DisplayInfo read(PacketBuffer buf) throws IOException
+    {
+        ITextComponent itextcomponent = buf.readTextComponent();
+        ITextComponent itextcomponent1 = buf.readTextComponent();
+        ItemStack itemstack = buf.readItemStack();
+        FrameType frametype = (FrameType)buf.readEnumValue(FrameType.class);
+        int i = buf.readInt();
+        ResourceLocation resourcelocation = (i & 1) != 0 ? buf.readResourceLocation() : null;
+        boolean flag = (i & 2) != 0;
+        boolean flag1 = (i & 4) != 0;
+        DisplayInfo displayinfo = new DisplayInfo(itemstack, itextcomponent, itextcomponent1, resourcelocation, frametype, flag, false, flag1);
+        displayinfo.setPosition(buf.readFloat(), buf.readFloat());
+        return displayinfo;
+    }
+}

build/tmp/recompileMc/sources/net/minecraft/advancements/FrameType.java

@@ -0,0 +1,52 @@
+package net.minecraft.advancements;
+
+import net.minecraft.util.text.TextFormatting;
+import net.minecraftforge.fml.relauncher.Side;
+import net.minecraftforge.fml.relauncher.SideOnly;
+
+public enum FrameType
+{
+    TASK("task", 0, TextFormatting.GREEN),
+    CHALLENGE("challenge", 26, TextFormatting.DARK_PURPLE),
+    GOAL("goal", 52, TextFormatting.GREEN);
+
+    private final String name;
+    private final int icon;
+    private final TextFormatting format;
+
+    private FrameType(String nameIn, int iconIn, TextFormatting formatIn)
+    {
+        this.name = nameIn;
+        this.icon = iconIn;
+        this.format = formatIn;
+    }
+
+    public String getName()
+    {
+        return this.name;
+    }
+
+    public static FrameType byName(String nameIn)
+    {
+        for (FrameType frametype : values())
+        {
+            if (frametype.name.equals(nameIn))
+            {
+                return frametype;
+            }
+        }
+
+        throw new IllegalArgumentException("Unknown frame type '" + nameIn + "'");
+    }
+
+    @SideOnly(Side.CLIENT)
+    public int getIcon()
+    {
+        return this.icon;
+    }
+
+    public TextFormatting getFormat()
+    {
+        return this.format;
+    }
+}

build/tmp/recompileMc/sources/net/minecraft/advancements/FunctionManager.java

@@ -0,0 +1,233 @@
+package net.minecraft.advancements;
+
+import com.google.common.collect.Maps;
+import com.google.common.io.Files;
+import java.io.File;
+import java.nio.charset.StandardCharsets;
+import java.util.ArrayDeque;
+import java.util.Map;
+import javax.annotation.Nullable;
+import net.minecraft.command.FunctionObject;
+import net.minecraft.command.ICommandManager;
+import net.minecraft.command.ICommandSender;
+import net.minecraft.server.MinecraftServer;
+import net.minecraft.util.ITickable;
+import net.minecraft.util.ResourceLocation;
+import net.minecraft.world.World;
+import org.apache.commons.io.FileUtils;
+import org.apache.commons.io.FilenameUtils;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+public class FunctionManager implements ITickable
+{
+    private static final Logger LOGGER = LogManager.getLogger();
+    private final File functionDir;
+    private final MinecraftServer server;
+    private final Map<ResourceLocation, FunctionObject> functions = Maps.<ResourceLocation, FunctionObject>newHashMap();
+    private String currentGameLoopFunctionId = "-";
+    private FunctionObject gameLoopFunction;
+    private final ArrayDeque<FunctionManager.QueuedCommand> commandQueue = new ArrayDeque<FunctionManager.QueuedCommand>();
+    private boolean isExecuting = false;
+    private final ICommandSender gameLoopFunctionSender = new ICommandSender()
+    {
+        /**
+         * Get the name of this object. For players this returns their username
+         */
+        public String getName()
+        {
+            return FunctionManager.this.currentGameLoopFunctionId;
+        }
+        /**
+         * Returns {@code true} if the CommandSender is allowed to execute the command, {@code false} if not
+         */
+        public boolean canUseCommand(int permLevel, String commandName)
+        {
+            return permLevel <= 2;
+        }
+        /**
+         * Get the world, if available. <b>{@code null} is not allowed!</b> If you are not an entity in the world,
+         * return the overworld
+         */
+        public World getEntityWorld()
+        {
+            return FunctionManager.this.server.worlds[0];
+        }
+        /**
+         * Get the Minecraft server instance
+         */
+        public MinecraftServer getServer()
+        {
+            return FunctionManager.this.server;
+        }
+    };
+
+    public FunctionManager(@Nullable File functionDirIn, MinecraftServer serverIn)
+    {
+        this.functionDir = functionDirIn;
+        this.server = serverIn;
+        this.reload();
+    }
+
+    @Nullable
+    public FunctionObject getFunction(ResourceLocation id)
+    {
+        return this.functions.get(id);
+    }
+
+    public ICommandManager getCommandManager()
+    {
+        return this.server.getCommandManager();
+    }
+
+    public int getMaxCommandChainLength()
+    {
+        return this.server.worlds[0].getGameRules().getInt("maxCommandChainLength");
+    }
+
+    public Map<ResourceLocation, FunctionObject> getFunctions()
+    {
+        return this.functions;
+    }
+
+    /**
+     * Like the old updateEntity(), except more generic.
+     */
+    public void update()
+    {
+        String s = this.server.worlds[0].getGameRules().getString("gameLoopFunction");
+
+        if (!s.equals(this.currentGameLoopFunctionId))
+        {
+            this.currentGameLoopFunctionId = s;
+            this.gameLoopFunction = this.getFunction(new ResourceLocation(s));
+        }
+
+        if (this.gameLoopFunction != null)
+        {
+            this.execute(this.gameLoopFunction, this.gameLoopFunctionSender);
+        }
+    }
+
+    public int execute(FunctionObject function, ICommandSender sender)
+    {
+        int i = this.getMaxCommandChainLength();
+
+        if (this.isExecuting)
+        {
+            if (this.commandQueue.size() < i)
+            {
+                this.commandQueue.addFirst(new FunctionManager.QueuedCommand(this, sender, new FunctionObject.FunctionEntry(function)));
+            }
+
+            return 0;
+        }
+        else
+        {
+            int l;
+
+            try
+            {
+                this.isExecuting = true;
+                int j = 0;
+                FunctionObject.Entry[] afunctionobject$entry = function.getEntries();
+
+                for (int k = afunctionobject$entry.length - 1; k >= 0; --k)
+                {
+                    this.commandQueue.push(new FunctionManager.QueuedCommand(this, sender, afunctionobject$entry[k]));
+                }
+
+                while (true)
+                {
+                    if (this.commandQueue.isEmpty())
+                    {
+                        l = j;
+                        return l;
+                    }
+
+                    (this.commandQueue.removeFirst()).execute(this.commandQueue, i);
+                    ++j;
+
+                    if (j >= i)
+                    {
+                        break;
+                    }
+                }
+
+                l = j;
+            }
+            finally
+            {
+                this.commandQueue.clear();
+                this.isExecuting = false;
+            }
+
+            return l;
+        }
+    }
+
+    public void reload()
+    {
+        this.functions.clear();
+        this.gameLoopFunction = null;
+        this.currentGameLoopFunctionId = "-";
+        this.loadFunctions();
+    }
+
+    private void loadFunctions()
+    {
+        if (this.functionDir != null)
+        {
+            this.functionDir.mkdirs();
+
+            for (File file1 : FileUtils.listFiles(this.functionDir, new String[] {"mcfunction"}, true))
+            {
+                String s = FilenameUtils.removeExtension(this.functionDir.toURI().relativize(file1.toURI()).toString());
+                String[] astring = s.split("/", 2);
+
+                if (astring.length == 2)
+                {
+                    ResourceLocation resourcelocation = new ResourceLocation(astring[0], astring[1]);
+
+                    try
+                    {
+                        this.functions.put(resourcelocation, FunctionObject.create(this, Files.readLines(file1, StandardCharsets.UTF_8)));
+                    }
+                    catch (Throwable throwable)
+                    {
+                        LOGGER.error("Couldn't read custom function " + resourcelocation + " from " + file1, throwable);
+                    }
+                }
+            }
+
+            if (!this.functions.isEmpty())
+            {
+                LOGGER.info("Loaded " + this.functions.size() + " custom command functions");
+            }
+        }
+    }
+
+    public static class QueuedCommand
+        {
+            private final FunctionManager functionManager;
+            private final ICommandSender sender;
+            private final FunctionObject.Entry entry;
+
+            public QueuedCommand(FunctionManager functionManagerIn, ICommandSender senderIn, FunctionObject.Entry entryIn)
+            {
+                this.functionManager = functionManagerIn;
+                this.sender = senderIn;
+                this.entry = entryIn;
+            }
+
+            public void execute(ArrayDeque<FunctionManager.QueuedCommand> commandQueue, int maxCommandChainLength)
+            {
+                this.entry.execute(this.functionManager, this.sender, commandQueue, maxCommandChainLength);
+            }
+
+            public String toString()
+            {
+                return this.entry.toString();
+            }
+        }
+}

build/tmp/recompileMc/sources/net/minecraft/advancements/ICriterionInstance.java

@@ -0,0 +1,8 @@
+package net.minecraft.advancements;
+
+import net.minecraft.util.ResourceLocation;
+
+public interface ICriterionInstance
+{
+    ResourceLocation getId();
+}

build/tmp/recompileMc/sources/net/minecraft/advancements/ICriterionTrigger.java

@@ -0,0 +1,78 @@
+package net.minecraft.advancements;
+
+import com.google.gson.JsonDeserializationContext;
+import com.google.gson.JsonObject;
+import net.minecraft.util.ResourceLocation;
+
+public interface ICriterionTrigger<T extends ICriterionInstance>
+{
+    ResourceLocation getId();
+
+    void addListener(PlayerAdvancements playerAdvancementsIn, ICriterionTrigger.Listener<T> listener);
+
+    void removeListener(PlayerAdvancements playerAdvancementsIn, ICriterionTrigger.Listener<T> listener);
+
+    void removeAllListeners(PlayerAdvancements playerAdvancementsIn);
+
+    /**
+     * Deserialize a ICriterionInstance of this trigger from the data in the JSON.
+     */
+    T deserializeInstance(JsonObject json, JsonDeserializationContext context);
+
+    public static class Listener<T extends ICriterionInstance>
+        {
+            private final T criterionInstance;
+            private final Advancement advancement;
+            private final String criterionName;
+
+            public Listener(T criterionInstanceIn, Advancement advancementIn, String criterionNameIn)
+            {
+                this.criterionInstance = criterionInstanceIn;
+                this.advancement = advancementIn;
+                this.criterionName = criterionNameIn;
+            }
+
+            public T getCriterionInstance()
+            {
+                return this.criterionInstance;
+            }
+
+            public void grantCriterion(PlayerAdvancements playerAdvancementsIn)
+            {
+                playerAdvancementsIn.grantCriterion(this.advancement, this.criterionName);
+            }
+
+            public boolean equals(Object p_equals_1_)
+            {
+                if (this == p_equals_1_)
+                {
+                    return true;
+                }
+                else if (p_equals_1_ != null && this.getClass() == p_equals_1_.getClass())
+                {
+                    ICriterionTrigger.Listener<?> listener = (ICriterionTrigger.Listener)p_equals_1_;
+
+                    if (!this.criterionInstance.equals(listener.criterionInstance))
+                    {
+                        return false;
+                    }
+                    else
+                    {
+                        return !this.advancement.equals(listener.advancement) ? false : this.criterionName.equals(listener.criterionName);
+                    }
+                }
+                else
+                {
+                    return false;
+                }
+            }
+
+            public int hashCode()
+            {
+                int i = this.criterionInstance.hashCode();
+                i = 31 * i + this.advancement.hashCode();
+                i = 31 * i + this.criterionName.hashCode();
+                return i;
+            }
+        }
+}

build/tmp/recompileMc/sources/net/minecraft/advancements/PlayerAdvancements.java

@@ -0,0 +1,468 @@
+package net.minecraft.advancements;
+
+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.JsonParseException;
+import com.google.gson.reflect.TypeToken;
+import java.io.File;
+import java.io.IOException;
+import java.nio.charset.StandardCharsets;
+import java.util.Comparator;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.Map.Entry;
+import java.util.function.Function;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+import javax.annotation.Nullable;
+import net.minecraft.entity.player.EntityPlayerMP;
+import net.minecraft.network.play.server.SPacketAdvancementInfo;
+import net.minecraft.network.play.server.SPacketSelectAdvancementsTab;
+import net.minecraft.server.MinecraftServer;
+import net.minecraft.util.JsonUtils;
+import net.minecraft.util.ResourceLocation;
+import net.minecraft.util.text.TextComponentTranslation;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+public class PlayerAdvancements
+{
+    private static final Logger LOGGER = LogManager.getLogger();
+    private static final Gson GSON = (new GsonBuilder()).registerTypeAdapter(AdvancementProgress.class, new AdvancementProgress.Serializer()).registerTypeAdapter(ResourceLocation.class, new ResourceLocation.Serializer()).setPrettyPrinting().create();
+    private static final TypeToken<Map<ResourceLocation, AdvancementProgress>> MAP_TOKEN = new TypeToken<Map<ResourceLocation, AdvancementProgress>>()
+    {
+    };
+    private final MinecraftServer server;
+    private final File progressFile;
+    private final Map<Advancement, AdvancementProgress> progress = Maps.<Advancement, AdvancementProgress>newLinkedHashMap();
+    private final Set<Advancement> visible = Sets.<Advancement>newLinkedHashSet();
+    private final Set<Advancement> visibilityChanged = Sets.<Advancement>newLinkedHashSet();
+    private final Set<Advancement> progressChanged = Sets.<Advancement>newLinkedHashSet();
+    private EntityPlayerMP player;
+    @Nullable
+    private Advancement lastSelectedTab;
+    private boolean isFirstPacket = true;
+
+    public PlayerAdvancements(MinecraftServer server, File p_i47422_2_, EntityPlayerMP player)
+    {
+        this.server = server;
+        this.progressFile = p_i47422_2_;
+        this.player = player;
+        this.load();
+    }
+
+    public void setPlayer(EntityPlayerMP player)
+    {
+        this.player = player;
+    }
+
+    public void dispose()
+    {
+        for (ICriterionTrigger<?> icriteriontrigger : CriteriaTriggers.getAll())
+        {
+            icriteriontrigger.removeAllListeners(this);
+        }
+    }
+
+    public void reload()
+    {
+        this.dispose();
+        this.progress.clear();
+        this.visible.clear();
+        this.visibilityChanged.clear();
+        this.progressChanged.clear();
+        this.isFirstPacket = true;
+        this.lastSelectedTab = null;
+        this.load();
+    }
+
+    private void registerListeners()
+    {
+        for (Advancement advancement : this.server.getAdvancementManager().getAdvancements())
+        {
+            this.registerListeners(advancement);
+        }
+    }
+
+    private void ensureAllVisible()
+    {
+        List<Advancement> list = Lists.<Advancement>newArrayList();
+
+        for (Entry<Advancement, AdvancementProgress> entry : this.progress.entrySet())
+        {
+            if (((AdvancementProgress)entry.getValue()).isDone())
+            {
+                list.add(entry.getKey());
+                this.progressChanged.add(entry.getKey());
+            }
+        }
+
+        for (Advancement advancement : list)
+        {
+            this.ensureVisibility(advancement);
+        }
+    }
+
+    private void checkForAutomaticTriggers()
+    {
+        for (Advancement advancement : this.server.getAdvancementManager().getAdvancements())
+        {
+            if (advancement.getCriteria().isEmpty())
+            {
+                this.grantCriterion(advancement, "");
+                advancement.getRewards().apply(this.player);
+            }
+        }
+    }
+
+    private void load()
+    {
+        if (this.progressFile.isFile())
+        {
+            try
+            {
+                String s = Files.toString(this.progressFile, StandardCharsets.UTF_8);
+                Map<ResourceLocation, AdvancementProgress> map = (Map)JsonUtils.gsonDeserialize(GSON, s, MAP_TOKEN.getType());
+
+                if (map == null)
+                {
+                    throw new JsonParseException("Found null for advancements");
+                }
+
+                Stream<Entry<ResourceLocation, AdvancementProgress>> stream = map.entrySet().stream().sorted(Comparator.comparing(Entry::getValue));
+
+                for (Entry<ResourceLocation, AdvancementProgress> entry : stream.collect(Collectors.toList()))
+                {
+                    Advancement advancement = this.server.getAdvancementManager().getAdvancement(entry.getKey());
+
+                    if (advancement == null)
+                    {
+                        LOGGER.warn("Ignored advancement '" + entry.getKey() + "' in progress file " + this.progressFile + " - it doesn't exist anymore?");
+                    }
+                    else
+                    {
+                        this.startProgress(advancement, entry.getValue());
+                    }
+                }
+            }
+            catch (JsonParseException jsonparseexception)
+            {
+                LOGGER.error("Couldn't parse player advancements in " + this.progressFile, (Throwable)jsonparseexception);
+            }
+            catch (IOException ioexception)
+            {
+                LOGGER.error("Couldn't access player advancements in " + this.progressFile, (Throwable)ioexception);
+            }
+        }
+
+        this.checkForAutomaticTriggers();
+        this.ensureAllVisible();
+        this.registerListeners();
+    }
+
+    public void save()
+    {
+        Map<ResourceLocation, AdvancementProgress> map = Maps.<ResourceLocation, AdvancementProgress>newHashMap();
+
+        for (Entry<Advancement, AdvancementProgress> entry : this.progress.entrySet())
+        {
+            AdvancementProgress advancementprogress = entry.getValue();
+
+            if (advancementprogress.hasProgress())
+            {
+                map.put(((Advancement)entry.getKey()).getId(), advancementprogress);
+            }
+        }
+
+        if (this.progressFile.getParentFile() != null)
+        {
+            this.progressFile.getParentFile().mkdirs();
+        }
+
+        try
+        {
+            Files.write(GSON.toJson(map), this.progressFile, StandardCharsets.UTF_8);
+        }
+        catch (IOException ioexception)
+        {
+            LOGGER.error("Couldn't save player advancements to " + this.progressFile, (Throwable)ioexception);
+        }
+    }
+
+    public boolean grantCriterion(Advancement p_192750_1_, String p_192750_2_)
+    {
+        // Forge: don't grant advancements for fake players
+        if (this.player instanceof net.minecraftforge.common.util.FakePlayer) return false;
+
+        boolean flag = false;
+        AdvancementProgress advancementprogress = this.getProgress(p_192750_1_);
+        boolean flag1 = advancementprogress.isDone();
+
+        if (advancementprogress.grantCriterion(p_192750_2_))
+        {
+            this.unregisterListeners(p_192750_1_);
+            this.progressChanged.add(p_192750_1_);
+            flag = true;
+
+            if (!flag1 && advancementprogress.isDone())
+            {
+                p_192750_1_.getRewards().apply(this.player);
+
+                if (p_192750_1_.getDisplay() != null && p_192750_1_.getDisplay().shouldAnnounceToChat() && this.player.world.getGameRules().getBoolean("announceAdvancements"))
+                {
+                    this.server.getPlayerList().sendMessage(new TextComponentTranslation("chat.type.advancement." + p_192750_1_.getDisplay().getFrame().getName(), new Object[] {this.player.getDisplayName(), p_192750_1_.getDisplayText()}));
+                }
+
+                net.minecraftforge.common.ForgeHooks.onAdvancement(this.player, p_192750_1_);
+            }
+        }
+
+        if (advancementprogress.isDone())
+        {
+            this.ensureVisibility(p_192750_1_);
+        }
+
+        return flag;
+    }
+
+    public boolean revokeCriterion(Advancement p_192744_1_, String p_192744_2_)
+    {
+        boolean flag = false;
+        AdvancementProgress advancementprogress = this.getProgress(p_192744_1_);
+
+        if (advancementprogress.revokeCriterion(p_192744_2_))
+        {
+            this.registerListeners(p_192744_1_);
+            this.progressChanged.add(p_192744_1_);
+            flag = true;
+        }
+
+        if (!advancementprogress.hasProgress())
+        {
+            this.ensureVisibility(p_192744_1_);
+        }
+
+        return flag;
+    }
+
+    private void registerListeners(Advancement p_193764_1_)
+    {
+        AdvancementProgress advancementprogress = this.getProgress(p_193764_1_);
+
+        if (!advancementprogress.isDone())
+        {
+            for (Entry<String, Criterion> entry : p_193764_1_.getCriteria().entrySet())
+            {
+                CriterionProgress criterionprogress = advancementprogress.getCriterionProgress(entry.getKey());
+
+                if (criterionprogress != null && !criterionprogress.isObtained())
+                {
+                    ICriterionInstance icriterioninstance = ((Criterion)entry.getValue()).getCriterionInstance();
+
+                    if (icriterioninstance != null)
+                    {
+                        ICriterionTrigger<ICriterionInstance> icriteriontrigger = CriteriaTriggers.<ICriterionInstance>get(icriterioninstance.getId());
+
+                        if (icriteriontrigger != null)
+                        {
+                            icriteriontrigger.addListener(this, new ICriterionTrigger.Listener(icriterioninstance, p_193764_1_, entry.getKey()));
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    private void unregisterListeners(Advancement p_193765_1_)
+    {
+        AdvancementProgress advancementprogress = this.getProgress(p_193765_1_);
+
+        for (Entry<String, Criterion> entry : p_193765_1_.getCriteria().entrySet())
+        {
+            CriterionProgress criterionprogress = advancementprogress.getCriterionProgress(entry.getKey());
+
+            if (criterionprogress != null && (criterionprogress.isObtained() || advancementprogress.isDone()))
+            {
+                ICriterionInstance icriterioninstance = ((Criterion)entry.getValue()).getCriterionInstance();
+
+                if (icriterioninstance != null)
+                {
+                    ICriterionTrigger<ICriterionInstance> icriteriontrigger = CriteriaTriggers.<ICriterionInstance>get(icriterioninstance.getId());
+
+                    if (icriteriontrigger != null)
+                    {
+                        icriteriontrigger.removeListener(this, new ICriterionTrigger.Listener(icriterioninstance, p_193765_1_, entry.getKey()));
+                    }
+                }
+            }
+        }
+    }
+
+    public void flushDirty(EntityPlayerMP p_192741_1_)
+    {
+        if (!this.visibilityChanged.isEmpty() || !this.progressChanged.isEmpty())
+        {
+            Map<ResourceLocation, AdvancementProgress> map = Maps.<ResourceLocation, AdvancementProgress>newHashMap();
+            Set<Advancement> set = Sets.<Advancement>newLinkedHashSet();
+            Set<ResourceLocation> set1 = Sets.<ResourceLocation>newLinkedHashSet();
+
+            for (Advancement advancement : this.progressChanged)
+            {
+                if (this.visible.contains(advancement))
+                {
+                    map.put(advancement.getId(), this.progress.get(advancement));
+                }
+            }
+
+            for (Advancement advancement1 : this.visibilityChanged)
+            {
+                if (this.visible.contains(advancement1))
+                {
+                    set.add(advancement1);
+                }
+                else
+                {
+                    set1.add(advancement1.getId());
+                }
+            }
+
+            if (!map.isEmpty() || !set.isEmpty() || !set1.isEmpty())
+            {
+                p_192741_1_.connection.sendPacket(new SPacketAdvancementInfo(this.isFirstPacket, set, set1, map));
+                this.visibilityChanged.clear();
+                this.progressChanged.clear();
+            }
+        }
+
+        this.isFirstPacket = false;
+    }
+
+    public void setSelectedTab(@Nullable Advancement p_194220_1_)
+    {
+        Advancement advancement = this.lastSelectedTab;
+
+        if (p_194220_1_ != null && p_194220_1_.getParent() == null && p_194220_1_.getDisplay() != null)
+        {
+            this.lastSelectedTab = p_194220_1_;
+        }
+        else
+        {
+            this.lastSelectedTab = null;
+        }
+
+        if (advancement != this.lastSelectedTab)
+        {
+            this.player.connection.sendPacket(new SPacketSelectAdvancementsTab(this.lastSelectedTab == null ? null : this.lastSelectedTab.getId()));
+        }
+    }
+
+    public AdvancementProgress getProgress(Advancement advancementIn)
+    {
+        AdvancementProgress advancementprogress = this.progress.get(advancementIn);
+
+        if (advancementprogress == null)
+        {
+            advancementprogress = new AdvancementProgress();
+            this.startProgress(advancementIn, advancementprogress);
+        }
+
+        return advancementprogress;
+    }
+
+    private void startProgress(Advancement p_192743_1_, AdvancementProgress p_192743_2_)
+    {
+        p_192743_2_.update(p_192743_1_.getCriteria(), p_192743_1_.getRequirements());
+        this.progress.put(p_192743_1_, p_192743_2_);
+    }
+
+    private void ensureVisibility(Advancement p_192742_1_)
+    {
+        boolean flag = this.shouldBeVisible(p_192742_1_);
+        boolean flag1 = this.visible.contains(p_192742_1_);
+
+        if (flag && !flag1)
+        {
+            this.visible.add(p_192742_1_);
+            this.visibilityChanged.add(p_192742_1_);
+
+            if (this.progress.containsKey(p_192742_1_))
+            {
+                this.progressChanged.add(p_192742_1_);
+            }
+        }
+        else if (!flag && flag1)
+        {
+            this.visible.remove(p_192742_1_);
+            this.visibilityChanged.add(p_192742_1_);
+        }
+
+        if (flag != flag1 && p_192742_1_.getParent() != null)
+        {
+            this.ensureVisibility(p_192742_1_.getParent());
+        }
+
+        for (Advancement advancement : p_192742_1_.getChildren())
+        {
+            this.ensureVisibility(advancement);
+        }
+    }
+
+    private boolean shouldBeVisible(Advancement p_192738_1_)
+    {
+        for (int i = 0; p_192738_1_ != null && i <= 2; ++i)
+        {
+            if (i == 0 && this.hasCompletedChildrenOrSelf(p_192738_1_))
+            {
+                return true;
+            }
+
+            if (p_192738_1_.getDisplay() == null)
+            {
+                return false;
+            }
+
+            AdvancementProgress advancementprogress = this.getProgress(p_192738_1_);
+
+            if (advancementprogress.isDone())
+            {
+                return true;
+            }
+
+            if (p_192738_1_.getDisplay().isHidden())
+            {
+                return false;
+            }
+
+            p_192738_1_ = p_192738_1_.getParent();
+        }
+
+        return false;
+    }
+
+    private boolean hasCompletedChildrenOrSelf(Advancement p_192746_1_)
+    {
+        AdvancementProgress advancementprogress = this.getProgress(p_192746_1_);
+
+        if (advancementprogress.isDone())
+        {
+            return true;
+        }
+        else
+        {
+            for (Advancement advancement : p_192746_1_.getChildren())
+            {
+                if (this.hasCompletedChildrenOrSelf(advancement))
+                {
+                    return true;
+                }
+            }
+
+            return false;
+        }
+    }
+}

build/tmp/recompileMc/sources/net/minecraft/advancements/critereon/AbstractCriterionInstance.java

@@ -0,0 +1,24 @@
+package net.minecraft.advancements.critereon;
+
+import net.minecraft.advancements.ICriterionInstance;
+import net.minecraft.util.ResourceLocation;
+
+public class AbstractCriterionInstance implements ICriterionInstance
+{
+    private final ResourceLocation criterion;
+
+    public AbstractCriterionInstance(ResourceLocation criterionIn)
+    {
+        this.criterion = criterionIn;
+    }
+
+    public ResourceLocation getId()
+    {
+        return this.criterion;
+    }
+
+    public String toString()
+    {
+        return "AbstractCriterionInstance{criterion=" + this.criterion + '}';
+    }
+}

build/tmp/recompileMc/sources/net/minecraft/advancements/critereon/BredAnimalsTrigger.java

@@ -0,0 +1,160 @@
+package net.minecraft.advancements.critereon;
+
+import com.google.common.collect.Lists;
+import com.google.common.collect.Maps;
+import com.google.common.collect.Sets;
+import com.google.gson.JsonDeserializationContext;
+import com.google.gson.JsonObject;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import net.minecraft.advancements.ICriterionTrigger;
+import net.minecraft.advancements.PlayerAdvancements;
+import net.minecraft.entity.EntityAgeable;
+import net.minecraft.entity.passive.EntityAnimal;
+import net.minecraft.entity.player.EntityPlayerMP;
+import net.minecraft.util.ResourceLocation;
+
+public class BredAnimalsTrigger implements ICriterionTrigger<BredAnimalsTrigger.Instance>
+{
+    private static final ResourceLocation ID = new ResourceLocation("bred_animals");
+    private final Map<PlayerAdvancements, BredAnimalsTrigger.Listeners> listeners = Maps.<PlayerAdvancements, BredAnimalsTrigger.Listeners>newHashMap();
+
+    public ResourceLocation getId()
+    {
+        return ID;
+    }
+
+    public void addListener(PlayerAdvancements playerAdvancementsIn, ICriterionTrigger.Listener<BredAnimalsTrigger.Instance> listener)
+    {
+        BredAnimalsTrigger.Listeners bredanimalstrigger$listeners = this.listeners.get(playerAdvancementsIn);
+
+        if (bredanimalstrigger$listeners == null)
+        {
+            bredanimalstrigger$listeners = new BredAnimalsTrigger.Listeners(playerAdvancementsIn);
+            this.listeners.put(playerAdvancementsIn, bredanimalstrigger$listeners);
+        }
+
+        bredanimalstrigger$listeners.add(listener);
+    }
+
+    public void removeListener(PlayerAdvancements playerAdvancementsIn, ICriterionTrigger.Listener<BredAnimalsTrigger.Instance> listener)
+    {
+        BredAnimalsTrigger.Listeners bredanimalstrigger$listeners = this.listeners.get(playerAdvancementsIn);
+
+        if (bredanimalstrigger$listeners != null)
+        {
+            bredanimalstrigger$listeners.remove(listener);
+
+            if (bredanimalstrigger$listeners.isEmpty())
+            {
+                this.listeners.remove(playerAdvancementsIn);
+            }
+        }
+    }
+
+    public void removeAllListeners(PlayerAdvancements playerAdvancementsIn)
+    {
+        this.listeners.remove(playerAdvancementsIn);
+    }
+
+    /**
+     * Deserialize a ICriterionInstance of this trigger from the data in the JSON.
+     */
+    public BredAnimalsTrigger.Instance deserializeInstance(JsonObject json, JsonDeserializationContext context)
+    {
+        EntityPredicate entitypredicate = EntityPredicate.deserialize(json.get("parent"));
+        EntityPredicate entitypredicate1 = EntityPredicate.deserialize(json.get("partner"));
+        EntityPredicate entitypredicate2 = EntityPredicate.deserialize(json.get("child"));
+        return new BredAnimalsTrigger.Instance(entitypredicate, entitypredicate1, entitypredicate2);
+    }
+
+    public void trigger(EntityPlayerMP player, EntityAnimal parent1, EntityAnimal parent2, EntityAgeable child)
+    {
+        BredAnimalsTrigger.Listeners bredanimalstrigger$listeners = this.listeners.get(player.getAdvancements());
+
+        if (bredanimalstrigger$listeners != null)
+        {
+            bredanimalstrigger$listeners.trigger(player, parent1, parent2, child);
+        }
+    }
+
+    public static class Instance extends AbstractCriterionInstance
+        {
+            private final EntityPredicate parent;
+            private final EntityPredicate partner;
+            private final EntityPredicate child;
+
+            public Instance(EntityPredicate parent, EntityPredicate partner, EntityPredicate child)
+            {
+                super(BredAnimalsTrigger.ID);
+                this.parent = parent;
+                this.partner = partner;
+                this.child = child;
+            }
+
+            public boolean test(EntityPlayerMP player, EntityAnimal parent1In, EntityAnimal parent2In, EntityAgeable childIn)
+            {
+                if (!this.child.test(player, childIn))
+                {
+                    return false;
+                }
+                else
+                {
+                    return this.parent.test(player, parent1In) && this.partner.test(player, parent2In) || this.parent.test(player, parent2In) && this.partner.test(player, parent1In);
+                }
+            }
+        }
+
+    static class Listeners
+        {
+            private final PlayerAdvancements playerAdvancements;
+            private final Set<ICriterionTrigger.Listener<BredAnimalsTrigger.Instance>> listeners = Sets.<ICriterionTrigger.Listener<BredAnimalsTrigger.Instance>>newHashSet();
+
+            public Listeners(PlayerAdvancements playerAdvancementsIn)
+            {
+                this.playerAdvancements = playerAdvancementsIn;
+            }
+
+            public boolean isEmpty()
+            {
+                return this.listeners.isEmpty();
+            }
+
+            public void add(ICriterionTrigger.Listener<BredAnimalsTrigger.Instance> listener)
+            {
+                this.listeners.add(listener);
+            }
+
+            public void remove(ICriterionTrigger.Listener<BredAnimalsTrigger.Instance> listener)
+            {
+                this.listeners.remove(listener);
+            }
+
+            public void trigger(EntityPlayerMP player, EntityAnimal parent1, EntityAnimal parent2, EntityAgeable child)
+            {
+                List<ICriterionTrigger.Listener<BredAnimalsTrigger.Instance>> list = null;
+
+                for (ICriterionTrigger.Listener<BredAnimalsTrigger.Instance> listener : this.listeners)
+                {
+                    if (((BredAnimalsTrigger.Instance)listener.getCriterionInstance()).test(player, parent1, parent2, child))
+                    {
+                        if (list == null)
+                        {
+                            list = Lists.<ICriterionTrigger.Listener<BredAnimalsTrigger.Instance>>newArrayList();
+                        }
+
+                        list.add(listener);
+                    }
+                }
+
+                if (list != null)
+                {
+                    for (ICriterionTrigger.Listener<BredAnimalsTrigger.Instance> listener1 : list)
+                    {
+                        listener1.grantCriterion(this.playerAdvancements);
+                    }
+                }
+            }
+        }
+}

build/tmp/recompileMc/sources/net/minecraft/advancements/critereon/BrewedPotionTrigger.java

@@ -0,0 +1,162 @@
+package net.minecraft.advancements.critereon;
+
+import com.google.common.collect.Lists;
+import com.google.common.collect.Maps;
+import com.google.common.collect.Sets;
+import com.google.gson.JsonDeserializationContext;
+import com.google.gson.JsonObject;
+import com.google.gson.JsonSyntaxException;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import javax.annotation.Nullable;
+import net.minecraft.advancements.ICriterionTrigger;
+import net.minecraft.advancements.PlayerAdvancements;
+import net.minecraft.entity.player.EntityPlayerMP;
+import net.minecraft.potion.PotionType;
+import net.minecraft.util.JsonUtils;
+import net.minecraft.util.ResourceLocation;
+
+public class BrewedPotionTrigger implements ICriterionTrigger<BrewedPotionTrigger.Instance>
+{
+    private static final ResourceLocation ID = new ResourceLocation("brewed_potion");
+    private final Map<PlayerAdvancements, BrewedPotionTrigger.Listeners> listeners = Maps.<PlayerAdvancements, BrewedPotionTrigger.Listeners>newHashMap();
+
+    public ResourceLocation getId()
+    {
+        return ID;
+    }
+
+    public void addListener(PlayerAdvancements playerAdvancementsIn, ICriterionTrigger.Listener<BrewedPotionTrigger.Instance> listener)
+    {
+        BrewedPotionTrigger.Listeners brewedpotiontrigger$listeners = this.listeners.get(playerAdvancementsIn);
+
+        if (brewedpotiontrigger$listeners == null)
+        {
+            brewedpotiontrigger$listeners = new BrewedPotionTrigger.Listeners(playerAdvancementsIn);
+            this.listeners.put(playerAdvancementsIn, brewedpotiontrigger$listeners);
+        }
+
+        brewedpotiontrigger$listeners.addListener(listener);
+    }
+
+    public void removeListener(PlayerAdvancements playerAdvancementsIn, ICriterionTrigger.Listener<BrewedPotionTrigger.Instance> listener)
+    {
+        BrewedPotionTrigger.Listeners brewedpotiontrigger$listeners = this.listeners.get(playerAdvancementsIn);
+
+        if (brewedpotiontrigger$listeners != null)
+        {
+            brewedpotiontrigger$listeners.removeListener(listener);
+
+            if (brewedpotiontrigger$listeners.isEmpty())
+            {
+                this.listeners.remove(playerAdvancementsIn);
+            }
+        }
+    }
+
+    public void removeAllListeners(PlayerAdvancements playerAdvancementsIn)
+    {
+        this.listeners.remove(playerAdvancementsIn);
+    }
+
+    /**
+     * Deserialize a ICriterionInstance of this trigger from the data in the JSON.
+     */
+    public BrewedPotionTrigger.Instance deserializeInstance(JsonObject json, JsonDeserializationContext context)
+    {
+        PotionType potiontype = null;
+
+        if (json.has("potion"))
+        {
+            ResourceLocation resourcelocation = new ResourceLocation(JsonUtils.getString(json, "potion"));
+
+            if (!PotionType.REGISTRY.containsKey(resourcelocation))
+            {
+                throw new JsonSyntaxException("Unknown potion '" + resourcelocation + "'");
+            }
+
+            potiontype = PotionType.REGISTRY.getObject(resourcelocation);
+        }
+
+        return new BrewedPotionTrigger.Instance(potiontype);
+    }
+
+    public void trigger(EntityPlayerMP player, PotionType potionIn)
+    {
+        BrewedPotionTrigger.Listeners brewedpotiontrigger$listeners = this.listeners.get(player.getAdvancements());
+
+        if (brewedpotiontrigger$listeners != null)
+        {
+            brewedpotiontrigger$listeners.trigger(potionIn);
+        }
+    }
+
+    public static class Instance extends AbstractCriterionInstance
+        {
+            private final PotionType potion;
+
+            public Instance(@Nullable PotionType potion)
+            {
+                super(BrewedPotionTrigger.ID);
+                this.potion = potion;
+            }
+
+            public boolean test(PotionType potion)
+            {
+                return this.potion == null || this.potion == potion;
+            }
+        }
+
+    static class Listeners
+        {
+            private final PlayerAdvancements playerAdvancements;
+            private final Set<ICriterionTrigger.Listener<BrewedPotionTrigger.Instance>> listeners = Sets.<ICriterionTrigger.Listener<BrewedPotionTrigger.Instance>>newHashSet();
+
+            public Listeners(PlayerAdvancements playerAdvancementsIn)
+            {
+                this.playerAdvancements = playerAdvancementsIn;
+            }
+
+            public boolean isEmpty()
+            {
+                return this.listeners.isEmpty();
+            }
+
+            public void addListener(ICriterionTrigger.Listener<BrewedPotionTrigger.Instance> listener)
+            {
+                this.listeners.add(listener);
+            }
+
+            public void removeListener(ICriterionTrigger.Listener<BrewedPotionTrigger.Instance> listener)
+            {
+                this.listeners.remove(listener);
+            }
+
+            public void trigger(PotionType potion)
+            {
+                List<ICriterionTrigger.Listener<BrewedPotionTrigger.Instance>> list = null;
+
+                for (ICriterionTrigger.Listener<BrewedPotionTrigger.Instance> listener : this.listeners)
+                {
+                    if (((BrewedPotionTrigger.Instance)listener.getCriterionInstance()).test(potion))
+                    {
+                        if (list == null)
+                        {
+                            list = Lists.<ICriterionTrigger.Listener<BrewedPotionTrigger.Instance>>newArrayList();
+                        }
+
+                        list.add(listener);
+                    }
+                }
+
+                if (list != null)
+                {
+                    for (ICriterionTrigger.Listener<BrewedPotionTrigger.Instance> listener1 : list)
+                    {
+                        listener1.grantCriterion(this.playerAdvancements);
+                    }
+                }
+            }
+        }
+}

build/tmp/recompileMc/sources/net/minecraft/advancements/critereon/ChangeDimensionTrigger.java

@@ -0,0 +1,160 @@
+package net.minecraft.advancements.critereon;
+
+import com.google.common.collect.Lists;
+import com.google.common.collect.Maps;
+import com.google.common.collect.Sets;
+import com.google.gson.JsonDeserializationContext;
+import com.google.gson.JsonObject;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import javax.annotation.Nullable;
+import net.minecraft.advancements.ICriterionTrigger;
+import net.minecraft.advancements.PlayerAdvancements;
+import net.minecraft.entity.player.EntityPlayerMP;
+import net.minecraft.util.JsonUtils;
+import net.minecraft.util.ResourceLocation;
+import net.minecraft.world.DimensionType;
+
+public class ChangeDimensionTrigger implements ICriterionTrigger<ChangeDimensionTrigger.Instance>
+{
+    private static final ResourceLocation ID = new ResourceLocation("changed_dimension");
+    private final Map<PlayerAdvancements, ChangeDimensionTrigger.Listeners> listeners = Maps.<PlayerAdvancements, ChangeDimensionTrigger.Listeners>newHashMap();
+
+    public ResourceLocation getId()
+    {
+        return ID;
+    }
+
+    public void addListener(PlayerAdvancements playerAdvancementsIn, ICriterionTrigger.Listener<ChangeDimensionTrigger.Instance> listener)
+    {
+        ChangeDimensionTrigger.Listeners changedimensiontrigger$listeners = this.listeners.get(playerAdvancementsIn);
+
+        if (changedimensiontrigger$listeners == null)
+        {
+            changedimensiontrigger$listeners = new ChangeDimensionTrigger.Listeners(playerAdvancementsIn);
+            this.listeners.put(playerAdvancementsIn, changedimensiontrigger$listeners);
+        }
+
+        changedimensiontrigger$listeners.add(listener);
+    }
+
+    public void removeListener(PlayerAdvancements playerAdvancementsIn, ICriterionTrigger.Listener<ChangeDimensionTrigger.Instance> listener)
+    {
+        ChangeDimensionTrigger.Listeners changedimensiontrigger$listeners = this.listeners.get(playerAdvancementsIn);
+
+        if (changedimensiontrigger$listeners != null)
+        {
+            changedimensiontrigger$listeners.remove(listener);
+
+            if (changedimensiontrigger$listeners.isEmpty())
+            {
+                this.listeners.remove(playerAdvancementsIn);
+            }
+        }
+    }
+
+    public void removeAllListeners(PlayerAdvancements playerAdvancementsIn)
+    {
+        this.listeners.remove(playerAdvancementsIn);
+    }
+
+    /**
+     * Deserialize a ICriterionInstance of this trigger from the data in the JSON.
+     */
+    public ChangeDimensionTrigger.Instance deserializeInstance(JsonObject json, JsonDeserializationContext context)
+    {
+        DimensionType dimensiontype = json.has("from") ? DimensionType.byName(JsonUtils.getString(json, "from")) : null;
+        DimensionType dimensiontype1 = json.has("to") ? DimensionType.byName(JsonUtils.getString(json, "to")) : null;
+        return new ChangeDimensionTrigger.Instance(dimensiontype, dimensiontype1);
+    }
+
+    public void trigger(EntityPlayerMP player, DimensionType from, DimensionType to)
+    {
+        ChangeDimensionTrigger.Listeners changedimensiontrigger$listeners = this.listeners.get(player.getAdvancements());
+
+        if (changedimensiontrigger$listeners != null)
+        {
+            changedimensiontrigger$listeners.trigger(from, to);
+        }
+    }
+
+    public static class Instance extends AbstractCriterionInstance
+        {
+            @Nullable
+            private final DimensionType from;
+            @Nullable
+            private final DimensionType to;
+
+            public Instance(@Nullable DimensionType from, @Nullable DimensionType to)
+            {
+                super(ChangeDimensionTrigger.ID);
+                this.from = from;
+                this.to = to;
+            }
+
+            public boolean test(DimensionType from, DimensionType to)
+            {
+                if (this.from != null && this.from != from)
+                {
+                    return false;
+                }
+                else
+                {
+                    return this.to == null || this.to == to;
+                }
+            }
+        }
+
+    static class Listeners
+        {
+            private final PlayerAdvancements playerAdvancements;
+            private final Set<ICriterionTrigger.Listener<ChangeDimensionTrigger.Instance>> listeners = Sets.<ICriterionTrigger.Listener<ChangeDimensionTrigger.Instance>>newHashSet();
+
+            public Listeners(PlayerAdvancements playerAdvancementsIn)
+            {
+                this.playerAdvancements = playerAdvancementsIn;
+            }
+
+            public boolean isEmpty()
+            {
+                return this.listeners.isEmpty();
+            }
+
+            public void add(ICriterionTrigger.Listener<ChangeDimensionTrigger.Instance> listener)
+            {
+                this.listeners.add(listener);
+            }
+
+            public void remove(ICriterionTrigger.Listener<ChangeDimensionTrigger.Instance> listener)
+            {
+                this.listeners.remove(listener);
+            }
+
+            public void trigger(DimensionType from, DimensionType to)
+            {
+                List<ICriterionTrigger.Listener<ChangeDimensionTrigger.Instance>> list = null;
+
+                for (ICriterionTrigger.Listener<ChangeDimensionTrigger.Instance> listener : this.listeners)
+                {
+                    if (((ChangeDimensionTrigger.Instance)listener.getCriterionInstance()).test(from, to))
+                    {
+                        if (list == null)
+                        {
+                            list = Lists.<ICriterionTrigger.Listener<ChangeDimensionTrigger.Instance>>newArrayList();
+                        }
+
+                        list.add(listener);
+                    }
+                }
+
+                if (list != null)
+                {
+                    for (ICriterionTrigger.Listener<ChangeDimensionTrigger.Instance> listener1 : list)
+                    {
+                        listener1.grantCriterion(this.playerAdvancements);
+                    }
+                }
+            }
+        }
+}

build/tmp/recompileMc/sources/net/minecraft/advancements/critereon/ConstructBeaconTrigger.java

@@ -0,0 +1,146 @@
+package net.minecraft.advancements.critereon;
+
+import com.google.common.collect.Lists;
+import com.google.common.collect.Maps;
+import com.google.common.collect.Sets;
+import com.google.gson.JsonDeserializationContext;
+import com.google.gson.JsonObject;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import net.minecraft.advancements.ICriterionTrigger;
+import net.minecraft.advancements.PlayerAdvancements;
+import net.minecraft.entity.player.EntityPlayerMP;
+import net.minecraft.tileentity.TileEntityBeacon;
+import net.minecraft.util.ResourceLocation;
+
+public class ConstructBeaconTrigger implements ICriterionTrigger<ConstructBeaconTrigger.Instance>
+{
+    private static final ResourceLocation ID = new ResourceLocation("construct_beacon");
+    private final Map<PlayerAdvancements, ConstructBeaconTrigger.Listeners> listeners = Maps.<PlayerAdvancements, ConstructBeaconTrigger.Listeners>newHashMap();
+
+    public ResourceLocation getId()
+    {
+        return ID;
+    }
+
+    public void addListener(PlayerAdvancements playerAdvancementsIn, ICriterionTrigger.Listener<ConstructBeaconTrigger.Instance> listener)
+    {
+        ConstructBeaconTrigger.Listeners constructbeacontrigger$listeners = this.listeners.get(playerAdvancementsIn);
+
+        if (constructbeacontrigger$listeners == null)
+        {
+            constructbeacontrigger$listeners = new ConstructBeaconTrigger.Listeners(playerAdvancementsIn);
+            this.listeners.put(playerAdvancementsIn, constructbeacontrigger$listeners);
+        }
+
+        constructbeacontrigger$listeners.add(listener);
+    }
+
+    public void removeListener(PlayerAdvancements playerAdvancementsIn, ICriterionTrigger.Listener<ConstructBeaconTrigger.Instance> listener)
+    {
+        ConstructBeaconTrigger.Listeners constructbeacontrigger$listeners = this.listeners.get(playerAdvancementsIn);
+
+        if (constructbeacontrigger$listeners != null)
+        {
+            constructbeacontrigger$listeners.remove(listener);
+
+            if (constructbeacontrigger$listeners.isEmpty())
+            {
+                this.listeners.remove(playerAdvancementsIn);
+            }
+        }
+    }
+
+    public void removeAllListeners(PlayerAdvancements playerAdvancementsIn)
+    {
+        this.listeners.remove(playerAdvancementsIn);
+    }
+
+    /**
+     * Deserialize a ICriterionInstance of this trigger from the data in the JSON.
+     */
+    public ConstructBeaconTrigger.Instance deserializeInstance(JsonObject json, JsonDeserializationContext context)
+    {
+        MinMaxBounds minmaxbounds = MinMaxBounds.deserialize(json.get("level"));
+        return new ConstructBeaconTrigger.Instance(minmaxbounds);
+    }
+
+    public void trigger(EntityPlayerMP player, TileEntityBeacon beacon)
+    {
+        ConstructBeaconTrigger.Listeners constructbeacontrigger$listeners = this.listeners.get(player.getAdvancements());
+
+        if (constructbeacontrigger$listeners != null)
+        {
+            constructbeacontrigger$listeners.trigger(beacon);
+        }
+    }
+
+    public static class Instance extends AbstractCriterionInstance
+        {
+            private final MinMaxBounds level;
+
+            public Instance(MinMaxBounds level)
+            {
+                super(ConstructBeaconTrigger.ID);
+                this.level = level;
+            }
+
+            public boolean test(TileEntityBeacon beacon)
+            {
+                return this.level.test((float)beacon.getLevels());
+            }
+        }
+
+    static class Listeners
+        {
+            private final PlayerAdvancements playerAdvancements;
+            private final Set<ICriterionTrigger.Listener<ConstructBeaconTrigger.Instance>> listeners = Sets.<ICriterionTrigger.Listener<ConstructBeaconTrigger.Instance>>newHashSet();
+
+            public Listeners(PlayerAdvancements playerAdvancementsIn)
+            {
+                this.playerAdvancements = playerAdvancementsIn;
+            }
+
+            public boolean isEmpty()
+            {
+                return this.listeners.isEmpty();
+            }
+
+            public void add(ICriterionTrigger.Listener<ConstructBeaconTrigger.Instance> listener)
+            {
+                this.listeners.add(listener);
+            }
+
+            public void remove(ICriterionTrigger.Listener<ConstructBeaconTrigger.Instance> listener)
+            {
+                this.listeners.remove(listener);
+            }
+
+            public void trigger(TileEntityBeacon beacon)
+            {
+                List<ICriterionTrigger.Listener<ConstructBeaconTrigger.Instance>> list = null;
+
+                for (ICriterionTrigger.Listener<ConstructBeaconTrigger.Instance> listener : this.listeners)
+                {
+                    if (((ConstructBeaconTrigger.Instance)listener.getCriterionInstance()).test(beacon))
+                    {
+                        if (list == null)
+                        {
+                            list = Lists.<ICriterionTrigger.Listener<ConstructBeaconTrigger.Instance>>newArrayList();
+                        }
+
+                        list.add(listener);
+                    }
+                }
+
+                if (list != null)
+                {
+                    for (ICriterionTrigger.Listener<ConstructBeaconTrigger.Instance> listener1 : list)
+                    {
+                        listener1.grantCriterion(this.playerAdvancements);
+                    }
+                }
+            }
+        }
+}

build/tmp/recompileMc/sources/net/minecraft/advancements/critereon/ConsumeItemTrigger.java

@@ -0,0 +1,146 @@
+package net.minecraft.advancements.critereon;
+
+import com.google.common.collect.Lists;
+import com.google.common.collect.Maps;
+import com.google.common.collect.Sets;
+import com.google.gson.JsonDeserializationContext;
+import com.google.gson.JsonObject;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import net.minecraft.advancements.ICriterionTrigger;
+import net.minecraft.advancements.PlayerAdvancements;
+import net.minecraft.entity.player.EntityPlayerMP;
+import net.minecraft.item.ItemStack;
+import net.minecraft.util.ResourceLocation;
+
+public class ConsumeItemTrigger implements ICriterionTrigger<ConsumeItemTrigger.Instance>
+{
+    private static final ResourceLocation ID = new ResourceLocation("consume_item");
+    private final Map<PlayerAdvancements, ConsumeItemTrigger.Listeners> listeners = Maps.<PlayerAdvancements, ConsumeItemTrigger.Listeners>newHashMap();
+
+    public ResourceLocation getId()
+    {
+        return ID;
+    }
+
+    public void addListener(PlayerAdvancements playerAdvancementsIn, ICriterionTrigger.Listener<ConsumeItemTrigger.Instance> listener)
+    {
+        ConsumeItemTrigger.Listeners consumeitemtrigger$listeners = this.listeners.get(playerAdvancementsIn);
+
+        if (consumeitemtrigger$listeners == null)
+        {
+            consumeitemtrigger$listeners = new ConsumeItemTrigger.Listeners(playerAdvancementsIn);
+            this.listeners.put(playerAdvancementsIn, consumeitemtrigger$listeners);
+        }
+
+        consumeitemtrigger$listeners.add(listener);
+    }
+
+    public void removeListener(PlayerAdvancements playerAdvancementsIn, ICriterionTrigger.Listener<ConsumeItemTrigger.Instance> listener)
+    {
+        ConsumeItemTrigger.Listeners consumeitemtrigger$listeners = this.listeners.get(playerAdvancementsIn);
+
+        if (consumeitemtrigger$listeners != null)
+        {
+            consumeitemtrigger$listeners.remove(listener);
+
+            if (consumeitemtrigger$listeners.isEmpty())
+            {
+                this.listeners.remove(playerAdvancementsIn);
+            }
+        }
+    }
+
+    public void removeAllListeners(PlayerAdvancements playerAdvancementsIn)
+    {
+        this.listeners.remove(playerAdvancementsIn);
+    }
+
+    /**
+     * Deserialize a ICriterionInstance of this trigger from the data in the JSON.
+     */
+    public ConsumeItemTrigger.Instance deserializeInstance(JsonObject json, JsonDeserializationContext context)
+    {
+        ItemPredicate itempredicate = ItemPredicate.deserialize(json.get("item"));
+        return new ConsumeItemTrigger.Instance(itempredicate);
+    }
+
+    public void trigger(EntityPlayerMP player, ItemStack item)
+    {
+        ConsumeItemTrigger.Listeners consumeitemtrigger$listeners = this.listeners.get(player.getAdvancements());
+
+        if (consumeitemtrigger$listeners != null)
+        {
+            consumeitemtrigger$listeners.trigger(item);
+        }
+    }
+
+    public static class Instance extends AbstractCriterionInstance
+        {
+            private final ItemPredicate item;
+
+            public Instance(ItemPredicate item)
+            {
+                super(ConsumeItemTrigger.ID);
+                this.item = item;
+            }
+
+            public boolean test(ItemStack item)
+            {
+                return this.item.test(item);
+            }
+        }
+
+    static class Listeners
+        {
+            private final PlayerAdvancements playerAdvancements;
+            private final Set<ICriterionTrigger.Listener<ConsumeItemTrigger.Instance>> listeners = Sets.<ICriterionTrigger.Listener<ConsumeItemTrigger.Instance>>newHashSet();
+
+            public Listeners(PlayerAdvancements playerAdvancementsIn)
+            {
+                this.playerAdvancements = playerAdvancementsIn;
+            }
+
+            public boolean isEmpty()
+            {
+                return this.listeners.isEmpty();
+            }
+
+            public void add(ICriterionTrigger.Listener<ConsumeItemTrigger.Instance> listener)
+            {
+                this.listeners.add(listener);
+            }
+
+            public void remove(ICriterionTrigger.Listener<ConsumeItemTrigger.Instance> listener)
+            {
+                this.listeners.remove(listener);
+            }
+
+            public void trigger(ItemStack item)
+            {
+                List<ICriterionTrigger.Listener<ConsumeItemTrigger.Instance>> list = null;
+
+                for (ICriterionTrigger.Listener<ConsumeItemTrigger.Instance> listener : this.listeners)
+                {
+                    if (((ConsumeItemTrigger.Instance)listener.getCriterionInstance()).test(item))
+                    {
+                        if (list == null)
+                        {
+                            list = Lists.<ICriterionTrigger.Listener<ConsumeItemTrigger.Instance>>newArrayList();
+                        }
+
+                        list.add(listener);
+                    }
+                }
+
+                if (list != null)
+                {
+                    for (ICriterionTrigger.Listener<ConsumeItemTrigger.Instance> listener1 : list)
+                    {
+                        listener1.grantCriterion(this.playerAdvancements);
+                    }
+                }
+            }
+        }
+}

build/tmp/recompileMc/sources/net/minecraft/advancements/critereon/CuredZombieVillagerTrigger.java

@@ -0,0 +1,157 @@
+package net.minecraft.advancements.critereon;
+
+import com.google.common.collect.Lists;
+import com.google.common.collect.Maps;
+import com.google.common.collect.Sets;
+import com.google.gson.JsonDeserializationContext;
+import com.google.gson.JsonObject;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import net.minecraft.advancements.ICriterionTrigger;
+import net.minecraft.advancements.PlayerAdvancements;
+import net.minecraft.entity.monster.EntityZombie;
+import net.minecraft.entity.passive.EntityVillager;
+import net.minecraft.entity.player.EntityPlayerMP;
+import net.minecraft.util.ResourceLocation;
+
+public class CuredZombieVillagerTrigger implements ICriterionTrigger<CuredZombieVillagerTrigger.Instance>
+{
+    private static final ResourceLocation ID = new ResourceLocation("cured_zombie_villager");
+    private final Map<PlayerAdvancements, CuredZombieVillagerTrigger.Listeners> listeners = Maps.<PlayerAdvancements, CuredZombieVillagerTrigger.Listeners>newHashMap();
+
+    public ResourceLocation getId()
+    {
+        return ID;
+    }
+
+    public void addListener(PlayerAdvancements playerAdvancementsIn, ICriterionTrigger.Listener<CuredZombieVillagerTrigger.Instance> listener)
+    {
+        CuredZombieVillagerTrigger.Listeners curedzombievillagertrigger$listeners = this.listeners.get(playerAdvancementsIn);
+
+        if (curedzombievillagertrigger$listeners == null)
+        {
+            curedzombievillagertrigger$listeners = new CuredZombieVillagerTrigger.Listeners(playerAdvancementsIn);
+            this.listeners.put(playerAdvancementsIn, curedzombievillagertrigger$listeners);
+        }
+
+        curedzombievillagertrigger$listeners.add(listener);
+    }
+
+    public void removeListener(PlayerAdvancements playerAdvancementsIn, ICriterionTrigger.Listener<CuredZombieVillagerTrigger.Instance> listener)
+    {
+        CuredZombieVillagerTrigger.Listeners curedzombievillagertrigger$listeners = this.listeners.get(playerAdvancementsIn);
+
+        if (curedzombievillagertrigger$listeners != null)
+        {
+            curedzombievillagertrigger$listeners.remove(listener);
+
+            if (curedzombievillagertrigger$listeners.isEmpty())
+            {
+                this.listeners.remove(playerAdvancementsIn);
+            }
+        }
+    }
+
+    public void removeAllListeners(PlayerAdvancements playerAdvancementsIn)
+    {
+        this.listeners.remove(playerAdvancementsIn);
+    }
+
+    /**
+     * Deserialize a ICriterionInstance of this trigger from the data in the JSON.
+     */
+    public CuredZombieVillagerTrigger.Instance deserializeInstance(JsonObject json, JsonDeserializationContext context)
+    {
+        EntityPredicate entitypredicate = EntityPredicate.deserialize(json.get("zombie"));
+        EntityPredicate entitypredicate1 = EntityPredicate.deserialize(json.get("villager"));
+        return new CuredZombieVillagerTrigger.Instance(entitypredicate, entitypredicate1);
+    }
+
+    public void trigger(EntityPlayerMP player, EntityZombie zombie, EntityVillager villager)
+    {
+        CuredZombieVillagerTrigger.Listeners curedzombievillagertrigger$listeners = this.listeners.get(player.getAdvancements());
+
+        if (curedzombievillagertrigger$listeners != null)
+        {
+            curedzombievillagertrigger$listeners.trigger(player, zombie, villager);
+        }
+    }
+
+    public static class Instance extends AbstractCriterionInstance
+        {
+            private final EntityPredicate zombie;
+            private final EntityPredicate villager;
+
+            public Instance(EntityPredicate zombie, EntityPredicate villager)
+            {
+                super(CuredZombieVillagerTrigger.ID);
+                this.zombie = zombie;
+                this.villager = villager;
+            }
+
+            public boolean test(EntityPlayerMP player, EntityZombie zombie, EntityVillager villager)
+            {
+                if (!this.zombie.test(player, zombie))
+                {
+                    return false;
+                }
+                else
+                {
+                    return this.villager.test(player, villager);
+                }
+            }
+        }
+
+    static class Listeners
+        {
+            private final PlayerAdvancements playerAdvancements;
+            private final Set<ICriterionTrigger.Listener<CuredZombieVillagerTrigger.Instance>> listeners = Sets.<ICriterionTrigger.Listener<CuredZombieVillagerTrigger.Instance>>newHashSet();
+
+            public Listeners(PlayerAdvancements playerAdvancementsIn)
+            {
+                this.playerAdvancements = playerAdvancementsIn;
+            }
+
+            public boolean isEmpty()
+            {
+                return this.listeners.isEmpty();
+            }
+
+            public void add(ICriterionTrigger.Listener<CuredZombieVillagerTrigger.Instance> listener)
+            {
+                this.listeners.add(listener);
+            }
+
+            public void remove(ICriterionTrigger.Listener<CuredZombieVillagerTrigger.Instance> listener)
+            {
+                this.listeners.remove(listener);
+            }
+
+            public void trigger(EntityPlayerMP player, EntityZombie zombie, EntityVillager villager)
+            {
+                List<ICriterionTrigger.Listener<CuredZombieVillagerTrigger.Instance>> list = null;
+
+                for (ICriterionTrigger.Listener<CuredZombieVillagerTrigger.Instance> listener : this.listeners)
+                {
+                    if (((CuredZombieVillagerTrigger.Instance)listener.getCriterionInstance()).test(player, zombie, villager))
+                    {
+                        if (list == null)
+                        {
+                            list = Lists.<ICriterionTrigger.Listener<CuredZombieVillagerTrigger.Instance>>newArrayList();
+                        }
+
+                        list.add(listener);
+                    }
+                }
+
+                if (list != null)
+                {
+                    for (ICriterionTrigger.Listener<CuredZombieVillagerTrigger.Instance> listener1 : list)
+                    {
+                        listener1.grantCriterion(this.playerAdvancements);
+                    }
+                }
+            }
+        }
+}

build/tmp/recompileMc/sources/net/minecraft/advancements/critereon/DamagePredicate.java

@@ -0,0 +1,82 @@
+package net.minecraft.advancements.critereon;
+
+import com.google.gson.JsonElement;
+import com.google.gson.JsonObject;
+import javax.annotation.Nullable;
+import net.minecraft.entity.player.EntityPlayerMP;
+import net.minecraft.util.DamageSource;
+import net.minecraft.util.JsonUtils;
+
+public class DamagePredicate
+{
+    public static DamagePredicate ANY = new DamagePredicate();
+    private final MinMaxBounds dealt;
+    private final MinMaxBounds taken;
+    private final EntityPredicate sourceEntity;
+    private final Boolean blocked;
+    private final DamageSourcePredicate type;
+
+    public DamagePredicate()
+    {
+        this.dealt = MinMaxBounds.UNBOUNDED;
+        this.taken = MinMaxBounds.UNBOUNDED;
+        this.sourceEntity = EntityPredicate.ANY;
+        this.blocked = null;
+        this.type = DamageSourcePredicate.ANY;
+    }
+
+    public DamagePredicate(MinMaxBounds dealt, MinMaxBounds taken, EntityPredicate sourceEntity, @Nullable Boolean blocked, DamageSourcePredicate type)
+    {
+        this.dealt = dealt;
+        this.taken = taken;
+        this.sourceEntity = sourceEntity;
+        this.blocked = blocked;
+        this.type = type;
+    }
+
+    public boolean test(EntityPlayerMP player, DamageSource source, float dealt, float taken, boolean blocked)
+    {
+        if (this == ANY)
+        {
+            return true;
+        }
+        else if (!this.dealt.test(dealt))
+        {
+            return false;
+        }
+        else if (!this.taken.test(taken))
+        {
+            return false;
+        }
+        else if (!this.sourceEntity.test(player, source.getTrueSource()))
+        {
+            return false;
+        }
+        else if (this.blocked != null && this.blocked.booleanValue() != blocked)
+        {
+            return false;
+        }
+        else
+        {
+            return this.type.test(player, source);
+        }
+    }
+
+    public static DamagePredicate deserialize(@Nullable JsonElement element)
+    {
+        if (element != null && !element.isJsonNull())
+        {
+            JsonObject jsonobject = JsonUtils.getJsonObject(element, "damage");
+            MinMaxBounds minmaxbounds = MinMaxBounds.deserialize(jsonobject.get("dealt"));
+            MinMaxBounds minmaxbounds1 = MinMaxBounds.deserialize(jsonobject.get("taken"));
+            Boolean obool = jsonobject.has("blocked") ? JsonUtils.getBoolean(jsonobject, "blocked") : null;
+            EntityPredicate entitypredicate = EntityPredicate.deserialize(jsonobject.get("source_entity"));
+            DamageSourcePredicate damagesourcepredicate = DamageSourcePredicate.deserialize(jsonobject.get("type"));
+            return new DamagePredicate(minmaxbounds, minmaxbounds1, entitypredicate, obool, damagesourcepredicate);
+        }
+        else
+        {
+            return ANY;
+        }
+    }
+}

build/tmp/recompileMc/sources/net/minecraft/advancements/critereon/DamageSourcePredicate.java

@@ -0,0 +1,120 @@
+package net.minecraft.advancements.critereon;
+
+import com.google.gson.JsonElement;
+import com.google.gson.JsonObject;
+import javax.annotation.Nullable;
+import net.minecraft.entity.player.EntityPlayerMP;
+import net.minecraft.util.DamageSource;
+import net.minecraft.util.JsonUtils;
+
+public class DamageSourcePredicate
+{
+    public static DamageSourcePredicate ANY = new DamageSourcePredicate();
+    private final Boolean isProjectile;
+    private final Boolean isExplosion;
+    private final Boolean bypassesArmor;
+    private final Boolean bypassesInvulnerability;
+    private final Boolean bypassesMagic;
+    private final Boolean isFire;
+    private final Boolean isMagic;
+    private final EntityPredicate directEntity;
+    private final EntityPredicate sourceEntity;
+
+    public DamageSourcePredicate()
+    {
+        this.isProjectile = null;
+        this.isExplosion = null;
+        this.bypassesArmor = null;
+        this.bypassesInvulnerability = null;
+        this.bypassesMagic = null;
+        this.isFire = null;
+        this.isMagic = null;
+        this.directEntity = EntityPredicate.ANY;
+        this.sourceEntity = EntityPredicate.ANY;
+    }
+
+    public DamageSourcePredicate(@Nullable Boolean isProjectile, @Nullable Boolean isExplosion, @Nullable Boolean bypassesArmor, @Nullable Boolean bypassesInvulnerability, @Nullable Boolean bypassesMagic, @Nullable Boolean isFire, @Nullable Boolean isMagic, EntityPredicate directEntity, EntityPredicate sourceEntity)
+    {
+        this.isProjectile = isProjectile;
+        this.isExplosion = isExplosion;
+        this.bypassesArmor = bypassesArmor;
+        this.bypassesInvulnerability = bypassesInvulnerability;
+        this.bypassesMagic = bypassesMagic;
+        this.isFire = isFire;
+        this.isMagic = isMagic;
+        this.directEntity = directEntity;
+        this.sourceEntity = sourceEntity;
+    }
+
+    public boolean test(EntityPlayerMP player, DamageSource source)
+    {
+        if (this == ANY)
+        {
+            return true;
+        }
+        else if (this.isProjectile != null && this.isProjectile.booleanValue() != source.isProjectile())
+        {
+            return false;
+        }
+        else if (this.isExplosion != null && this.isExplosion.booleanValue() != source.isExplosion())
+        {
+            return false;
+        }
+        else if (this.bypassesArmor != null && this.bypassesArmor.booleanValue() != source.isUnblockable())
+        {
+            return false;
+        }
+        else if (this.bypassesInvulnerability != null && this.bypassesInvulnerability.booleanValue() != source.canHarmInCreative())
+        {
+            return false;
+        }
+        else if (this.bypassesMagic != null && this.bypassesMagic.booleanValue() != source.isDamageAbsolute())
+        {
+            return false;
+        }
+        else if (this.isFire != null && this.isFire.booleanValue() != source.isFireDamage())
+        {
+            return false;
+        }
+        else if (this.isMagic != null && this.isMagic.booleanValue() != source.isMagicDamage())
+        {
+            return false;
+        }
+        else if (!this.directEntity.test(player, source.getImmediateSource()))
+        {
+            return false;
+        }
+        else
+        {
+            return this.sourceEntity.test(player, source.getTrueSource());
+        }
+    }
+
+    public static DamageSourcePredicate deserialize(@Nullable JsonElement element)
+    {
+        if (element != null && !element.isJsonNull())
+        {
+            JsonObject jsonobject = JsonUtils.getJsonObject(element, "damage type");
+            Boolean obool = optionalBoolean(jsonobject, "is_projectile");
+            Boolean obool1 = optionalBoolean(jsonobject, "is_explosion");
+            Boolean obool2 = optionalBoolean(jsonobject, "bypasses_armor");
+            Boolean obool3 = optionalBoolean(jsonobject, "bypasses_invulnerability");
+            Boolean obool4 = optionalBoolean(jsonobject, "bypasses_magic");
+            Boolean obool5 = optionalBoolean(jsonobject, "is_fire");
+            Boolean obool6 = optionalBoolean(jsonobject, "is_magic");
+            EntityPredicate entitypredicate = EntityPredicate.deserialize(jsonobject.get("direct_entity"));
+            EntityPredicate entitypredicate1 = EntityPredicate.deserialize(jsonobject.get("source_entity"));
+            return new DamageSourcePredicate(obool, obool1, obool2, obool3, obool4, obool5, obool6, entitypredicate, entitypredicate1);
+        }
+        else
+        {
+            return ANY;
+        }
+    }
+
+    @Nullable
+    private static Boolean optionalBoolean(JsonObject object, String memberName)
+    {
+        return object.has(memberName) ? JsonUtils.getBoolean(object, memberName) : null;
+    }
+}

build/tmp/recompileMc/sources/net/minecraft/advancements/critereon/DistancePredicate.java

@@ -0,0 +1,68 @@
+package net.minecraft.advancements.critereon;
+
+import com.google.gson.JsonElement;
+import com.google.gson.JsonObject;
+import javax.annotation.Nullable;
+import net.minecraft.util.JsonUtils;
+import net.minecraft.util.math.MathHelper;
+
+public class DistancePredicate
+{
+    /** The predicate that matches any distance. */
+    public static final DistancePredicate ANY = new DistancePredicate(MinMaxBounds.UNBOUNDED, MinMaxBounds.UNBOUNDED, MinMaxBounds.UNBOUNDED, MinMaxBounds.UNBOUNDED, MinMaxBounds.UNBOUNDED);
+    private final MinMaxBounds x;
+    private final MinMaxBounds y;
+    private final MinMaxBounds z;
+    private final MinMaxBounds horizontal;
+    private final MinMaxBounds absolute;
+
+    public DistancePredicate(MinMaxBounds x, MinMaxBounds y, MinMaxBounds z, MinMaxBounds horizontal, MinMaxBounds absolute)
+    {
+        this.x = x;
+        this.y = y;
+        this.z = z;
+        this.horizontal = horizontal;
+        this.absolute = absolute;
+    }
+
+    public boolean test(double x1, double y1, double z1, double x2, double y2, double z2)
+    {
+        float f = (float)(x1 - x2);
+        float f1 = (float)(y1 - y2);
+        float f2 = (float)(z1 - z2);
+
+        if (this.x.test(MathHelper.abs(f)) && this.y.test(MathHelper.abs(f1)) && this.z.test(MathHelper.abs(f2)))
+        {
+            if (!this.horizontal.testSquare((double)(f * f + f2 * f2)))
+            {
+                return false;
+            }
+            else
+            {
+                return this.absolute.testSquare((double)(f * f + f1 * f1 + f2 * f2));
+            }
+        }
+        else
+        {
+            return false;
+        }
+    }
+
+    public static DistancePredicate deserialize(@Nullable JsonElement element)
+    {
+        if (element != null && !element.isJsonNull())
+        {
+            JsonObject jsonobject = JsonUtils.getJsonObject(element, "distance");
+            MinMaxBounds minmaxbounds = MinMaxBounds.deserialize(jsonobject.get("x"));
+            MinMaxBounds minmaxbounds1 = MinMaxBounds.deserialize(jsonobject.get("y"));
+            MinMaxBounds minmaxbounds2 = MinMaxBounds.deserialize(jsonobject.get("z"));
+            MinMaxBounds minmaxbounds3 = MinMaxBounds.deserialize(jsonobject.get("horizontal"));
+            MinMaxBounds minmaxbounds4 = MinMaxBounds.deserialize(jsonobject.get("absolute"));
+            return new DistancePredicate(minmaxbounds, minmaxbounds1, minmaxbounds2, minmaxbounds3, minmaxbounds4);
+        }
+        else
+        {
+            return ANY;
+        }
+    }
+}

build/tmp/recompileMc/sources/net/minecraft/advancements/critereon/EffectsChangedTrigger.java

@@ -0,0 +1,145 @@
+package net.minecraft.advancements.critereon;
+
+import com.google.common.collect.Lists;
+import com.google.common.collect.Maps;
+import com.google.common.collect.Sets;
+import com.google.gson.JsonDeserializationContext;
+import com.google.gson.JsonObject;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import net.minecraft.advancements.ICriterionTrigger;
+import net.minecraft.advancements.PlayerAdvancements;
+import net.minecraft.entity.player.EntityPlayerMP;
+import net.minecraft.util.ResourceLocation;
+
+public class EffectsChangedTrigger implements ICriterionTrigger<EffectsChangedTrigger.Instance>
+{
+    private static final ResourceLocation ID = new ResourceLocation("effects_changed");
+    private final Map<PlayerAdvancements, EffectsChangedTrigger.Listeners> listeners = Maps.<PlayerAdvancements, EffectsChangedTrigger.Listeners>newHashMap();
+
+    public ResourceLocation getId()
+    {
+        return ID;
+    }
+
+    public void addListener(PlayerAdvancements playerAdvancementsIn, ICriterionTrigger.Listener<EffectsChangedTrigger.Instance> listener)
+    {
+        EffectsChangedTrigger.Listeners effectschangedtrigger$listeners = this.listeners.get(playerAdvancementsIn);
+
+        if (effectschangedtrigger$listeners == null)
+        {
+            effectschangedtrigger$listeners = new EffectsChangedTrigger.Listeners(playerAdvancementsIn);
+            this.listeners.put(playerAdvancementsIn, effectschangedtrigger$listeners);
+        }
+
+        effectschangedtrigger$listeners.add(listener);
+    }
+
+    public void removeListener(PlayerAdvancements playerAdvancementsIn, ICriterionTrigger.Listener<EffectsChangedTrigger.Instance> listener)
+    {
+        EffectsChangedTrigger.Listeners effectschangedtrigger$listeners = this.listeners.get(playerAdvancementsIn);
+
+        if (effectschangedtrigger$listeners != null)
+        {
+            effectschangedtrigger$listeners.remove(listener);
+
+            if (effectschangedtrigger$listeners.isEmpty())
+            {
+                this.listeners.remove(playerAdvancementsIn);
+            }
+        }
+    }
+
+    public void removeAllListeners(PlayerAdvancements playerAdvancementsIn)
+    {
+        this.listeners.remove(playerAdvancementsIn);
+    }
+
+    /**
+     * Deserialize a ICriterionInstance of this trigger from the data in the JSON.
+     */
+    public EffectsChangedTrigger.Instance deserializeInstance(JsonObject json, JsonDeserializationContext context)
+    {
+        MobEffectsPredicate mobeffectspredicate = MobEffectsPredicate.deserialize(json.get("effects"));
+        return new EffectsChangedTrigger.Instance(mobeffectspredicate);
+    }
+
+    public void trigger(EntityPlayerMP player)
+    {
+        EffectsChangedTrigger.Listeners effectschangedtrigger$listeners = this.listeners.get(player.getAdvancements());
+
+        if (effectschangedtrigger$listeners != null)
+        {
+            effectschangedtrigger$listeners.trigger(player);
+        }
+    }
+
+    public static class Instance extends AbstractCriterionInstance
+        {
+            private final MobEffectsPredicate effects;
+
+            public Instance(MobEffectsPredicate effects)
+            {
+                super(EffectsChangedTrigger.ID);
+                this.effects = effects;
+            }
+
+            public boolean test(EntityPlayerMP player)
+            {
+                return this.effects.test(player);
+            }
+        }
+
+    static class Listeners
+        {
+            private final PlayerAdvancements playerAdvancements;
+            private final Set<ICriterionTrigger.Listener<EffectsChangedTrigger.Instance>> listeners = Sets.<ICriterionTrigger.Listener<EffectsChangedTrigger.Instance>>newHashSet();
+
+            public Listeners(PlayerAdvancements playerAdvancementsIn)
+            {
+                this.playerAdvancements = playerAdvancementsIn;
+            }
+
+            public boolean isEmpty()
+            {
+                return this.listeners.isEmpty();
+            }
+
+            public void add(ICriterionTrigger.Listener<EffectsChangedTrigger.Instance> listener)
+            {
+                this.listeners.add(listener);
+            }
+
+            public void remove(ICriterionTrigger.Listener<EffectsChangedTrigger.Instance> listener)
+            {
+                this.listeners.remove(listener);
+            }
+
+            public void trigger(EntityPlayerMP player)
+            {
+                List<ICriterionTrigger.Listener<EffectsChangedTrigger.Instance>> list = null;
+
+                for (ICriterionTrigger.Listener<EffectsChangedTrigger.Instance> listener : this.listeners)
+                {
+                    if (((EffectsChangedTrigger.Instance)listener.getCriterionInstance()).test(player))
+                    {
+                        if (list == null)
+                        {
+                            list = Lists.<ICriterionTrigger.Listener<EffectsChangedTrigger.Instance>>newArrayList();
+                        }
+
+                        list.add(listener);
+                    }
+                }
+
+                if (list != null)
+                {
+                    for (ICriterionTrigger.Listener<EffectsChangedTrigger.Instance> listener1 : list)
+                    {
+                        listener1.grantCriterion(this.playerAdvancements);
+                    }
+                }
+            }
+        }
+}

build/tmp/recompileMc/sources/net/minecraft/advancements/critereon/EnchantedItemTrigger.java

@@ -0,0 +1,156 @@
+package net.minecraft.advancements.critereon;
+
+import com.google.common.collect.Lists;
+import com.google.common.collect.Maps;
+import com.google.common.collect.Sets;
+import com.google.gson.JsonDeserializationContext;
+import com.google.gson.JsonObject;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import net.minecraft.advancements.ICriterionTrigger;
+import net.minecraft.advancements.PlayerAdvancements;
+import net.minecraft.entity.player.EntityPlayerMP;
+import net.minecraft.item.ItemStack;
+import net.minecraft.util.ResourceLocation;
+
+public class EnchantedItemTrigger implements ICriterionTrigger<EnchantedItemTrigger.Instance>
+{
+    private static final ResourceLocation ID = new ResourceLocation("enchanted_item");
+    private final Map<PlayerAdvancements, EnchantedItemTrigger.Listeners> listeners = Maps.<PlayerAdvancements, EnchantedItemTrigger.Listeners>newHashMap();
+
+    public ResourceLocation getId()
+    {
+        return ID;
+    }
+
+    public void addListener(PlayerAdvancements playerAdvancementsIn, ICriterionTrigger.Listener<EnchantedItemTrigger.Instance> listener)
+    {
+        EnchantedItemTrigger.Listeners enchanteditemtrigger$listeners = this.listeners.get(playerAdvancementsIn);
+
+        if (enchanteditemtrigger$listeners == null)
+        {
+            enchanteditemtrigger$listeners = new EnchantedItemTrigger.Listeners(playerAdvancementsIn);
+            this.listeners.put(playerAdvancementsIn, enchanteditemtrigger$listeners);
+        }
+
+        enchanteditemtrigger$listeners.add(listener);
+    }
+
+    public void removeListener(PlayerAdvancements playerAdvancementsIn, ICriterionTrigger.Listener<EnchantedItemTrigger.Instance> listener)
+    {
+        EnchantedItemTrigger.Listeners enchanteditemtrigger$listeners = this.listeners.get(playerAdvancementsIn);
+
+        if (enchanteditemtrigger$listeners != null)
+        {
+            enchanteditemtrigger$listeners.remove(listener);
+
+            if (enchanteditemtrigger$listeners.isEmpty())
+            {
+                this.listeners.remove(playerAdvancementsIn);
+            }
+        }
+    }
+
+    public void removeAllListeners(PlayerAdvancements playerAdvancementsIn)
+    {
+        this.listeners.remove(playerAdvancementsIn);
+    }
+
+    /**
+     * Deserialize a ICriterionInstance of this trigger from the data in the JSON.
+     */
+    public EnchantedItemTrigger.Instance deserializeInstance(JsonObject json, JsonDeserializationContext context)
+    {
+        ItemPredicate itempredicate = ItemPredicate.deserialize(json.get("item"));
+        MinMaxBounds minmaxbounds = MinMaxBounds.deserialize(json.get("levels"));
+        return new EnchantedItemTrigger.Instance(itempredicate, minmaxbounds);
+    }
+
+    public void trigger(EntityPlayerMP player, ItemStack item, int levelsSpent)
+    {
+        EnchantedItemTrigger.Listeners enchanteditemtrigger$listeners = this.listeners.get(player.getAdvancements());
+
+        if (enchanteditemtrigger$listeners != null)
+        {
+            enchanteditemtrigger$listeners.trigger(item, levelsSpent);
+        }
+    }
+
+    public static class Instance extends AbstractCriterionInstance
+        {
+            private final ItemPredicate item;
+            private final MinMaxBounds levels;
+
+            public Instance(ItemPredicate item, MinMaxBounds levels)
+            {
+                super(EnchantedItemTrigger.ID);
+                this.item = item;
+                this.levels = levels;
+            }
+
+            public boolean test(ItemStack item, int levelsIn)
+            {
+                if (!this.item.test(item))
+                {
+                    return false;
+                }
+                else
+                {
+                    return this.levels.test((float)levelsIn);
+                }
+            }
+        }
+
+    static class Listeners
+        {
+            private final PlayerAdvancements playerAdvancements;
+            private final Set<ICriterionTrigger.Listener<EnchantedItemTrigger.Instance>> listeners = Sets.<ICriterionTrigger.Listener<EnchantedItemTrigger.Instance>>newHashSet();
+
+            public Listeners(PlayerAdvancements playerAdvancementsIn)
+            {
+                this.playerAdvancements = playerAdvancementsIn;
+            }
+
+            public boolean isEmpty()
+            {
+                return this.listeners.isEmpty();
+            }
+
+            public void add(ICriterionTrigger.Listener<EnchantedItemTrigger.Instance> listener)
+            {
+                this.listeners.add(listener);
+            }
+
+            public void remove(ICriterionTrigger.Listener<EnchantedItemTrigger.Instance> listener)
+            {
+                this.listeners.remove(listener);
+            }
+
+            public void trigger(ItemStack item, int levelsIn)
+            {
+                List<ICriterionTrigger.Listener<EnchantedItemTrigger.Instance>> list = null;
+
+                for (ICriterionTrigger.Listener<EnchantedItemTrigger.Instance> listener : this.listeners)
+                {
+                    if (((EnchantedItemTrigger.Instance)listener.getCriterionInstance()).test(item, levelsIn))
+                    {
+                        if (list == null)
+                        {
+                            list = Lists.<ICriterionTrigger.Listener<EnchantedItemTrigger.Instance>>newArrayList();
+                        }
+
+                        list.add(listener);
+                    }
+                }
+
+                if (list != null)
+                {
+                    for (ICriterionTrigger.Listener<EnchantedItemTrigger.Instance> listener1 : list)
+                    {
+                        listener1.grantCriterion(this.playerAdvancements);
+                    }
+                }
+            }
+        }
+}

build/tmp/recompileMc/sources/net/minecraft/advancements/critereon/EnchantmentPredicate.java

@@ -0,0 +1,110 @@
+package net.minecraft.advancements.critereon;
+
+import com.google.gson.JsonArray;
+import com.google.gson.JsonElement;
+import com.google.gson.JsonObject;
+import com.google.gson.JsonSyntaxException;
+import java.util.Map;
+import javax.annotation.Nullable;
+import net.minecraft.enchantment.Enchantment;
+import net.minecraft.util.JsonUtils;
+import net.minecraft.util.ResourceLocation;
+
+public class EnchantmentPredicate
+{
+    /** The predicate that matches any set of enchantments. */
+    public static final EnchantmentPredicate ANY = new EnchantmentPredicate();
+    private final Enchantment enchantment;
+    private final MinMaxBounds levels;
+
+    public EnchantmentPredicate()
+    {
+        this.enchantment = null;
+        this.levels = MinMaxBounds.UNBOUNDED;
+    }
+
+    public EnchantmentPredicate(@Nullable Enchantment enchantment, MinMaxBounds levels)
+    {
+        this.enchantment = enchantment;
+        this.levels = levels;
+    }
+
+    public boolean test(Map<Enchantment, Integer> enchantmentsIn)
+    {
+        if (this.enchantment != null)
+        {
+            if (!enchantmentsIn.containsKey(this.enchantment))
+            {
+                return false;
+            }
+
+            int i = ((Integer)enchantmentsIn.get(this.enchantment)).intValue();
+
+            if (this.levels != null && !this.levels.test((float)i))
+            {
+                return false;
+            }
+        }
+        else if (this.levels != null)
+        {
+            for (Integer integer : enchantmentsIn.values())
+            {
+                if (this.levels.test((float)integer.intValue()))
+                {
+                    return true;
+                }
+            }
+
+            return false;
+        }
+
+        return true;
+    }
+
+    public static EnchantmentPredicate deserialize(@Nullable JsonElement element)
+    {
+        if (element != null && !element.isJsonNull())
+        {
+            JsonObject jsonobject = JsonUtils.getJsonObject(element, "enchantment");
+            Enchantment enchantment = null;
+
+            if (jsonobject.has("enchantment"))
+            {
+                ResourceLocation resourcelocation = new ResourceLocation(JsonUtils.getString(jsonobject, "enchantment"));
+                enchantment = Enchantment.REGISTRY.getObject(resourcelocation);
+
+                if (enchantment == null)
+                {
+                    throw new JsonSyntaxException("Unknown enchantment '" + resourcelocation + "'");
+                }
+            }
+
+            MinMaxBounds minmaxbounds = MinMaxBounds.deserialize(jsonobject.get("levels"));
+            return new EnchantmentPredicate(enchantment, minmaxbounds);
+        }
+        else
+        {
+            return ANY;
+        }
+    }
+
+    public static EnchantmentPredicate[] deserializeArray(@Nullable JsonElement element)
+    {
+        if (element != null && !element.isJsonNull())
+        {
+            JsonArray jsonarray = JsonUtils.getJsonArray(element, "enchantments");
+            EnchantmentPredicate[] aenchantmentpredicate = new EnchantmentPredicate[jsonarray.size()];
+
+            for (int i = 0; i < aenchantmentpredicate.length; ++i)
+            {
+                aenchantmentpredicate[i] = deserialize(jsonarray.get(i));
+            }
+
+            return aenchantmentpredicate;
+        }
+        else
+        {
+            return new EnchantmentPredicate[0];
+        }
+    }
+}

build/tmp/recompileMc/sources/net/minecraft/advancements/critereon/EnterBlockTrigger.java

@@ -0,0 +1,225 @@
+package net.minecraft.advancements.critereon;
+
+import com.google.common.base.Optional;
+import com.google.common.collect.Lists;
+import com.google.common.collect.Maps;
+import com.google.common.collect.Sets;
+import com.google.gson.JsonDeserializationContext;
+import com.google.gson.JsonElement;
+import com.google.gson.JsonObject;
+import com.google.gson.JsonSyntaxException;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.Map.Entry;
+import javax.annotation.Nullable;
+import net.minecraft.advancements.ICriterionTrigger;
+import net.minecraft.advancements.PlayerAdvancements;
+import net.minecraft.block.Block;
+import net.minecraft.block.properties.IProperty;
+import net.minecraft.block.state.BlockStateContainer;
+import net.minecraft.block.state.IBlockState;
+import net.minecraft.entity.player.EntityPlayerMP;
+import net.minecraft.util.JsonUtils;
+import net.minecraft.util.ResourceLocation;
+
+public class EnterBlockTrigger implements ICriterionTrigger<EnterBlockTrigger.Instance>
+{
+    private static final ResourceLocation ID = new ResourceLocation("enter_block");
+    private final Map<PlayerAdvancements, EnterBlockTrigger.Listeners> listeners = Maps.<PlayerAdvancements, EnterBlockTrigger.Listeners>newHashMap();
+
+    public ResourceLocation getId()
+    {
+        return ID;
+    }
+
+    public void addListener(PlayerAdvancements playerAdvancementsIn, ICriterionTrigger.Listener<EnterBlockTrigger.Instance> listener)
+    {
+        EnterBlockTrigger.Listeners enterblocktrigger$listeners = this.listeners.get(playerAdvancementsIn);
+
+        if (enterblocktrigger$listeners == null)
+        {
+            enterblocktrigger$listeners = new EnterBlockTrigger.Listeners(playerAdvancementsIn);
+            this.listeners.put(playerAdvancementsIn, enterblocktrigger$listeners);
+        }
+
+        enterblocktrigger$listeners.add(listener);
+    }
+
+    public void removeListener(PlayerAdvancements playerAdvancementsIn, ICriterionTrigger.Listener<EnterBlockTrigger.Instance> listener)
+    {
+        EnterBlockTrigger.Listeners enterblocktrigger$listeners = this.listeners.get(playerAdvancementsIn);
+
+        if (enterblocktrigger$listeners != null)
+        {
+            enterblocktrigger$listeners.remove(listener);
+
+            if (enterblocktrigger$listeners.isEmpty())
+            {
+                this.listeners.remove(playerAdvancementsIn);
+            }
+        }
+    }
+
+    public void removeAllListeners(PlayerAdvancements playerAdvancementsIn)
+    {
+        this.listeners.remove(playerAdvancementsIn);
+    }
+
+    /**
+     * Deserialize a ICriterionInstance of this trigger from the data in the JSON.
+     */
+    public EnterBlockTrigger.Instance deserializeInstance(JsonObject json, JsonDeserializationContext context)
+    {
+        Block block = null;
+
+        if (json.has("block"))
+        {
+            ResourceLocation resourcelocation = new ResourceLocation(JsonUtils.getString(json, "block"));
+
+            if (!Block.REGISTRY.containsKey(resourcelocation))
+            {
+                throw new JsonSyntaxException("Unknown block type '" + resourcelocation + "'");
+            }
+
+            block = Block.REGISTRY.getObject(resourcelocation);
+        }
+
+        Map < IProperty<?>, Object > map = null;
+
+        if (json.has("state"))
+        {
+            if (block == null)
+            {
+                throw new JsonSyntaxException("Can't define block state without a specific block type");
+            }
+
+            BlockStateContainer blockstatecontainer = block.getBlockState();
+
+            for (Entry<String, JsonElement> entry : JsonUtils.getJsonObject(json, "state").entrySet())
+            {
+                IProperty<?> iproperty = blockstatecontainer.getProperty(entry.getKey());
+
+                if (iproperty == null)
+                {
+                    throw new JsonSyntaxException("Unknown block state property '" + (String)entry.getKey() + "' for block '" + Block.REGISTRY.getNameForObject(block) + "'");
+                }
+
+                String s = JsonUtils.getString(entry.getValue(), entry.getKey());
+                Optional<?> optional = iproperty.parseValue(s);
+
+                if (!optional.isPresent())
+                {
+                    throw new JsonSyntaxException("Invalid block state value '" + s + "' for property '" + (String)entry.getKey() + "' on block '" + Block.REGISTRY.getNameForObject(block) + "'");
+                }
+
+                if (map == null)
+                {
+                    map = Maps. < IProperty<?>, Object > newHashMap();
+                }
+
+                map.put(iproperty, optional.get());
+            }
+        }
+
+        return new EnterBlockTrigger.Instance(block, map);
+    }
+
+    public void trigger(EntityPlayerMP player, IBlockState state)
+    {
+        EnterBlockTrigger.Listeners enterblocktrigger$listeners = this.listeners.get(player.getAdvancements());
+
+        if (enterblocktrigger$listeners != null)
+        {
+            enterblocktrigger$listeners.trigger(state);
+        }
+    }
+
+    public static class Instance extends AbstractCriterionInstance
+        {
+            private final Block block;
+            private final Map < IProperty<?>, Object > properties;
+
+            public Instance(@Nullable Block blockIn, @Nullable Map < IProperty<?>, Object > propertiesIn)
+            {
+                super(EnterBlockTrigger.ID);
+                this.block = blockIn;
+                this.properties = propertiesIn;
+            }
+
+            public boolean test(IBlockState state)
+            {
+                if (this.block != null && state.getBlock() != this.block)
+                {
+                    return false;
+                }
+                else
+                {
+                    if (this.properties != null)
+                    {
+                        for (Entry < IProperty<?>, Object > entry : this.properties.entrySet())
+                        {
+                            if (state.getValue(entry.getKey()) != entry.getValue())
+                            {
+                                return false;
+                            }
+                        }
+                    }
+
+                    return true;
+                }
+            }
+        }
+
+    static class Listeners
+        {
+            private final PlayerAdvancements playerAdvancements;
+            private final Set<ICriterionTrigger.Listener<EnterBlockTrigger.Instance>> listeners = Sets.<ICriterionTrigger.Listener<EnterBlockTrigger.Instance>>newHashSet();
+
+            public Listeners(PlayerAdvancements playerAdvancementsIn)
+            {
+                this.playerAdvancements = playerAdvancementsIn;
+            }
+
+            public boolean isEmpty()
+            {
+                return this.listeners.isEmpty();
+            }
+
+            public void add(ICriterionTrigger.Listener<EnterBlockTrigger.Instance> listener)
+            {
+                this.listeners.add(listener);
+            }
+
+            public void remove(ICriterionTrigger.Listener<EnterBlockTrigger.Instance> listener)
+            {
+                this.listeners.remove(listener);
+            }
+
+            public void trigger(IBlockState state)
+            {
+                List<ICriterionTrigger.Listener<EnterBlockTrigger.Instance>> list = null;
+
+                for (ICriterionTrigger.Listener<EnterBlockTrigger.Instance> listener : this.listeners)
+                {
+                    if (((EnterBlockTrigger.Instance)listener.getCriterionInstance()).test(state))
+                    {
+                        if (list == null)
+                        {
+                            list = Lists.<ICriterionTrigger.Listener<EnterBlockTrigger.Instance>>newArrayList();
+                        }
+
+                        list.add(listener);
+                    }
+                }
+
+                if (list != null)
+                {
+                    for (ICriterionTrigger.Listener<EnterBlockTrigger.Instance> listener1 : list)
+                    {
+                        listener1.grantCriterion(this.playerAdvancements);
+                    }
+                }
+            }
+        }
+}

build/tmp/recompileMc/sources/net/minecraft/advancements/critereon/EntityHurtPlayerTrigger.java

@@ -0,0 +1,146 @@
+package net.minecraft.advancements.critereon;
+
+import com.google.common.collect.Lists;
+import com.google.common.collect.Maps;
+import com.google.common.collect.Sets;
+import com.google.gson.JsonDeserializationContext;
+import com.google.gson.JsonObject;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import net.minecraft.advancements.ICriterionTrigger;
+import net.minecraft.advancements.PlayerAdvancements;
+import net.minecraft.entity.player.EntityPlayerMP;
+import net.minecraft.util.DamageSource;
+import net.minecraft.util.ResourceLocation;
+
+public class EntityHurtPlayerTrigger implements ICriterionTrigger<EntityHurtPlayerTrigger.Instance>
+{
+    private static final ResourceLocation ID = new ResourceLocation("entity_hurt_player");
+    private final Map<PlayerAdvancements, EntityHurtPlayerTrigger.Listeners> listeners = Maps.<PlayerAdvancements, EntityHurtPlayerTrigger.Listeners>newHashMap();
+
+    public ResourceLocation getId()
+    {
+        return ID;
+    }
+
+    public void addListener(PlayerAdvancements playerAdvancementsIn, ICriterionTrigger.Listener<EntityHurtPlayerTrigger.Instance> listener)
+    {
+        EntityHurtPlayerTrigger.Listeners entityhurtplayertrigger$listeners = this.listeners.get(playerAdvancementsIn);
+
+        if (entityhurtplayertrigger$listeners == null)
+        {
+            entityhurtplayertrigger$listeners = new EntityHurtPlayerTrigger.Listeners(playerAdvancementsIn);
+            this.listeners.put(playerAdvancementsIn, entityhurtplayertrigger$listeners);
+        }
+
+        entityhurtplayertrigger$listeners.add(listener);
+    }
+
+    public void removeListener(PlayerAdvancements playerAdvancementsIn, ICriterionTrigger.Listener<EntityHurtPlayerTrigger.Instance> listener)
+    {
+        EntityHurtPlayerTrigger.Listeners entityhurtplayertrigger$listeners = this.listeners.get(playerAdvancementsIn);
+
+        if (entityhurtplayertrigger$listeners != null)
+        {
+            entityhurtplayertrigger$listeners.remove(listener);
+
+            if (entityhurtplayertrigger$listeners.isEmpty())
+            {
+                this.listeners.remove(playerAdvancementsIn);
+            }
+        }
+    }
+
+    public void removeAllListeners(PlayerAdvancements playerAdvancementsIn)
+    {
+        this.listeners.remove(playerAdvancementsIn);
+    }
+
+    /**
+     * Deserialize a ICriterionInstance of this trigger from the data in the JSON.
+     */
+    public EntityHurtPlayerTrigger.Instance deserializeInstance(JsonObject json, JsonDeserializationContext context)
+    {
+        DamagePredicate damagepredicate = DamagePredicate.deserialize(json.get("damage"));
+        return new EntityHurtPlayerTrigger.Instance(damagepredicate);
+    }
+
+    public void trigger(EntityPlayerMP player, DamageSource source, float amountDealt, float amountTaken, boolean wasBlocked)
+    {
+        EntityHurtPlayerTrigger.Listeners entityhurtplayertrigger$listeners = this.listeners.get(player.getAdvancements());
+
+        if (entityhurtplayertrigger$listeners != null)
+        {
+            entityhurtplayertrigger$listeners.trigger(player, source, amountDealt, amountTaken, wasBlocked);
+        }
+    }
+
+    public static class Instance extends AbstractCriterionInstance
+        {
+            private final DamagePredicate damage;
+
+            public Instance(DamagePredicate damage)
+            {
+                super(EntityHurtPlayerTrigger.ID);
+                this.damage = damage;
+            }
+
+            public boolean test(EntityPlayerMP player, DamageSource source, float amountDealt, float amountTaken, boolean wasBlocked)
+            {
+                return this.damage.test(player, source, amountDealt, amountTaken, wasBlocked);
+            }
+        }
+
+    static class Listeners
+        {
+            private final PlayerAdvancements playerAdvancements;
+            private final Set<ICriterionTrigger.Listener<EntityHurtPlayerTrigger.Instance>> listeners = Sets.<ICriterionTrigger.Listener<EntityHurtPlayerTrigger.Instance>>newHashSet();
+
+            public Listeners(PlayerAdvancements p_i47439_1_)
+            {
+                this.playerAdvancements = p_i47439_1_;
+            }
+
+            public boolean isEmpty()
+            {
+                return this.listeners.isEmpty();
+            }
+
+            public void add(ICriterionTrigger.Listener<EntityHurtPlayerTrigger.Instance> listener)
+            {
+                this.listeners.add(listener);
+            }
+
+            public void remove(ICriterionTrigger.Listener<EntityHurtPlayerTrigger.Instance> listener)
+            {
+                this.listeners.remove(listener);
+            }
+
+            public void trigger(EntityPlayerMP player, DamageSource source, float amountDealt, float amountTaken, boolean wasBlocked)
+            {
+                List<ICriterionTrigger.Listener<EntityHurtPlayerTrigger.Instance>> list = null;
+
+                for (ICriterionTrigger.Listener<EntityHurtPlayerTrigger.Instance> listener : this.listeners)
+                {
+                    if (((EntityHurtPlayerTrigger.Instance)listener.getCriterionInstance()).test(player, source, amountDealt, amountTaken, wasBlocked))
+                    {
+                        if (list == null)
+                        {
+                            list = Lists.<ICriterionTrigger.Listener<EntityHurtPlayerTrigger.Instance>>newArrayList();
+                        }
+
+                        list.add(listener);
+                    }
+                }
+
+                if (list != null)
+                {
+                    for (ICriterionTrigger.Listener<EntityHurtPlayerTrigger.Instance> listener1 : list)
+                    {
+                        listener1.grantCriterion(this.playerAdvancements);
+                    }
+                }
+            }
+        }
+}

build/tmp/recompileMc/sources/net/minecraft/advancements/critereon/EntityPredicate.java

@@ -0,0 +1,92 @@
+package net.minecraft.advancements.critereon;
+
+import com.google.gson.JsonElement;
+import com.google.gson.JsonObject;
+import com.google.gson.JsonSyntaxException;
+import javax.annotation.Nullable;
+import net.minecraft.entity.Entity;
+import net.minecraft.entity.EntityList;
+import net.minecraft.entity.player.EntityPlayerMP;
+import net.minecraft.util.JsonUtils;
+import net.minecraft.util.ResourceLocation;
+
+public class EntityPredicate
+{
+    /** The predicate that matches any entity. */
+    public static final EntityPredicate ANY = new EntityPredicate((ResourceLocation)null, DistancePredicate.ANY, LocationPredicate.ANY, MobEffectsPredicate.ANY, NBTPredicate.ANY);
+    private final ResourceLocation type;
+    private final DistancePredicate distance;
+    private final LocationPredicate location;
+    private final MobEffectsPredicate effects;
+    private final NBTPredicate nbt;
+
+    public EntityPredicate(@Nullable ResourceLocation type, DistancePredicate distance, LocationPredicate location, MobEffectsPredicate effects, NBTPredicate nbt)
+    {
+        this.type = type;
+        this.distance = distance;
+        this.location = location;
+        this.effects = effects;
+        this.nbt = nbt;
+    }
+
+    public boolean test(EntityPlayerMP player, @Nullable Entity entity)
+    {
+        if (this == ANY)
+        {
+            return true;
+        }
+        else if (entity == null)
+        {
+            return false;
+        }
+        else if (this.type != null && !EntityList.isMatchingName(entity, this.type))
+        {
+            return false;
+        }
+        else if (!this.distance.test(player.posX, player.posY, player.posZ, entity.posX, entity.posY, entity.posZ))
+        {
+            return false;
+        }
+        else if (!this.location.test(player.getServerWorld(), entity.posX, entity.posY, entity.posZ))
+        {
+            return false;
+        }
+        else if (!this.effects.test(entity))
+        {
+            return false;
+        }
+        else
+        {
+            return this.nbt.test(entity);
+        }
+    }
+
+    public static EntityPredicate deserialize(@Nullable JsonElement element)
+    {
+        if (element != null && !element.isJsonNull())
+        {
+            JsonObject jsonobject = JsonUtils.getJsonObject(element, "entity");
+            ResourceLocation resourcelocation = null;
+
+            if (jsonobject.has("type"))
+            {
+                resourcelocation = new ResourceLocation(JsonUtils.getString(jsonobject, "type"));
+
+                if (!EntityList.isRegistered(resourcelocation))
+                {
+                    throw new JsonSyntaxException("Unknown entity type '" + resourcelocation + "', valid types are: " + EntityList.getValidTypeNames());
+                }
+            }
+
+            DistancePredicate distancepredicate = DistancePredicate.deserialize(jsonobject.get("distance"));
+            LocationPredicate locationpredicate = LocationPredicate.deserialize(jsonobject.get("location"));
+            MobEffectsPredicate mobeffectspredicate = MobEffectsPredicate.deserialize(jsonobject.get("effects"));
+            NBTPredicate nbtpredicate = NBTPredicate.deserialize(jsonobject.get("nbt"));
+            return new EntityPredicate(resourcelocation, distancepredicate, locationpredicate, mobeffectspredicate, nbtpredicate);
+        }
+        else
+        {
+            return ANY;
+        }
+    }
+}

build/tmp/recompileMc/sources/net/minecraft/advancements/critereon/ImpossibleTrigger.java

@@ -0,0 +1,45 @@
+package net.minecraft.advancements.critereon;
+
+import com.google.gson.JsonDeserializationContext;
+import com.google.gson.JsonObject;
+import net.minecraft.advancements.ICriterionTrigger;
+import net.minecraft.advancements.PlayerAdvancements;
+import net.minecraft.util.ResourceLocation;
+
+public class ImpossibleTrigger implements ICriterionTrigger<ImpossibleTrigger.Instance>
+{
+    private static final ResourceLocation ID = new ResourceLocation("impossible");
+
+    public ResourceLocation getId()
+    {
+        return ID;
+    }
+
+    public void addListener(PlayerAdvancements playerAdvancementsIn, ICriterionTrigger.Listener<ImpossibleTrigger.Instance> listener)
+    {
+    }
+
+    public void removeListener(PlayerAdvancements playerAdvancementsIn, ICriterionTrigger.Listener<ImpossibleTrigger.Instance> listener)
+    {
+    }
+
+    public void removeAllListeners(PlayerAdvancements playerAdvancementsIn)
+    {
+    }
+
+    /**
+     * Deserialize a ICriterionInstance of this trigger from the data in the JSON.
+     */
+    public ImpossibleTrigger.Instance deserializeInstance(JsonObject json, JsonDeserializationContext context)
+    {
+        return new ImpossibleTrigger.Instance();
+    }
+
+    public static class Instance extends AbstractCriterionInstance
+        {
+            public Instance()
+            {
+                super(ImpossibleTrigger.ID);
+            }
+        }
+}

build/tmp/recompileMc/sources/net/minecraft/advancements/critereon/InventoryChangeTrigger.java

@@ -0,0 +1,214 @@
+package net.minecraft.advancements.critereon;
+
+import com.google.common.collect.Lists;
+import com.google.common.collect.Maps;
+import com.google.common.collect.Sets;
+import com.google.gson.JsonDeserializationContext;
+import com.google.gson.JsonObject;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import net.minecraft.advancements.ICriterionTrigger;
+import net.minecraft.advancements.PlayerAdvancements;
+import net.minecraft.entity.player.EntityPlayerMP;
+import net.minecraft.entity.player.InventoryPlayer;
+import net.minecraft.item.ItemStack;
+import net.minecraft.util.JsonUtils;
+import net.minecraft.util.ResourceLocation;
+
+public class InventoryChangeTrigger implements ICriterionTrigger<InventoryChangeTrigger.Instance>
+{
+    private static final ResourceLocation ID = new ResourceLocation("inventory_changed");
+    private final Map<PlayerAdvancements, InventoryChangeTrigger.Listeners> listeners = Maps.<PlayerAdvancements, InventoryChangeTrigger.Listeners>newHashMap();
+
+    public ResourceLocation getId()
+    {
+        return ID;
+    }
+
+    public void addListener(PlayerAdvancements playerAdvancementsIn, ICriterionTrigger.Listener<InventoryChangeTrigger.Instance> listener)
+    {
+        InventoryChangeTrigger.Listeners inventorychangetrigger$listeners = this.listeners.get(playerAdvancementsIn);
+
+        if (inventorychangetrigger$listeners == null)
+        {
+            inventorychangetrigger$listeners = new InventoryChangeTrigger.Listeners(playerAdvancementsIn);
+            this.listeners.put(playerAdvancementsIn, inventorychangetrigger$listeners);
+        }
+
+        inventorychangetrigger$listeners.add(listener);
+    }
+
+    public void removeListener(PlayerAdvancements playerAdvancementsIn, ICriterionTrigger.Listener<InventoryChangeTrigger.Instance> listener)
+    {
+        InventoryChangeTrigger.Listeners inventorychangetrigger$listeners = this.listeners.get(playerAdvancementsIn);
+
+        if (inventorychangetrigger$listeners != null)
+        {
+            inventorychangetrigger$listeners.remove(listener);
+
+            if (inventorychangetrigger$listeners.isEmpty())
+            {
+                this.listeners.remove(playerAdvancementsIn);
+            }
+        }
+    }
+
+    public void removeAllListeners(PlayerAdvancements playerAdvancementsIn)
+    {
+        this.listeners.remove(playerAdvancementsIn);
+    }
+
+    /**
+     * Deserialize a ICriterionInstance of this trigger from the data in the JSON.
+     */
+    public InventoryChangeTrigger.Instance deserializeInstance(JsonObject json, JsonDeserializationContext context)
+    {
+        JsonObject jsonobject = JsonUtils.getJsonObject(json, "slots", new JsonObject());
+        MinMaxBounds minmaxbounds = MinMaxBounds.deserialize(jsonobject.get("occupied"));
+        MinMaxBounds minmaxbounds1 = MinMaxBounds.deserialize(jsonobject.get("full"));
+        MinMaxBounds minmaxbounds2 = MinMaxBounds.deserialize(jsonobject.get("empty"));
+        ItemPredicate[] aitempredicate = ItemPredicate.deserializeArray(json.get("items"));
+        return new InventoryChangeTrigger.Instance(minmaxbounds, minmaxbounds1, minmaxbounds2, aitempredicate);
+    }
+
+    public void trigger(EntityPlayerMP player, InventoryPlayer inventory)
+    {
+        InventoryChangeTrigger.Listeners inventorychangetrigger$listeners = this.listeners.get(player.getAdvancements());
+
+        if (inventorychangetrigger$listeners != null)
+        {
+            inventorychangetrigger$listeners.trigger(inventory);
+        }
+    }
+
+    public static class Instance extends AbstractCriterionInstance
+        {
+            private final MinMaxBounds occupied;
+            private final MinMaxBounds full;
+            private final MinMaxBounds empty;
+            private final ItemPredicate[] items;
+
+            public Instance(MinMaxBounds occupied, MinMaxBounds full, MinMaxBounds empty, ItemPredicate[] items)
+            {
+                super(InventoryChangeTrigger.ID);
+                this.occupied = occupied;
+                this.full = full;
+                this.empty = empty;
+                this.items = items;
+            }
+
+            public boolean test(InventoryPlayer inventory)
+            {
+                int i = 0;
+                int j = 0;
+                int k = 0;
+                List<ItemPredicate> list = Lists.newArrayList(this.items);
+
+                for (int l = 0; l < inventory.getSizeInventory(); ++l)
+                {
+                    ItemStack itemstack = inventory.getStackInSlot(l);
+
+                    if (itemstack.isEmpty())
+                    {
+                        ++j;
+                    }
+                    else
+                    {
+                        ++k;
+
+                        if (itemstack.getCount() >= itemstack.getMaxStackSize())
+                        {
+                            ++i;
+                        }
+
+                        Iterator<ItemPredicate> iterator = list.iterator();
+
+                        while (iterator.hasNext())
+                        {
+                            ItemPredicate itempredicate = iterator.next();
+
+                            if (itempredicate.test(itemstack))
+                            {
+                                iterator.remove();
+                            }
+                        }
+                    }
+                }
+
+                if (!this.full.test((float)i))
+                {
+                    return false;
+                }
+                else if (!this.empty.test((float)j))
+                {
+                    return false;
+                }
+                else if (!this.occupied.test((float)k))
+                {
+                    return false;
+                }
+                else if (!list.isEmpty())
+                {
+                    return false;
+                }
+                else
+                {
+                    return true;
+                }
+            }
+        }
+
+    static class Listeners
+        {
+            private final PlayerAdvancements playerAdvancements;
+            private final Set<ICriterionTrigger.Listener<InventoryChangeTrigger.Instance>> listeners = Sets.<ICriterionTrigger.Listener<InventoryChangeTrigger.Instance>>newHashSet();
+
+            public Listeners(PlayerAdvancements playerAdvancementsIn)
+            {
+                this.playerAdvancements = playerAdvancementsIn;
+            }
+
+            public boolean isEmpty()
+            {
+                return this.listeners.isEmpty();
+            }
+
+            public void add(ICriterionTrigger.Listener<InventoryChangeTrigger.Instance> listener)
+            {
+                this.listeners.add(listener);
+            }
+
+            public void remove(ICriterionTrigger.Listener<InventoryChangeTrigger.Instance> listener)
+            {
+                this.listeners.remove(listener);
+            }
+
+            public void trigger(InventoryPlayer inventory)
+            {
+                List<ICriterionTrigger.Listener<InventoryChangeTrigger.Instance>> list = null;
+
+                for (ICriterionTrigger.Listener<InventoryChangeTrigger.Instance> listener : this.listeners)
+                {
+                    if (((InventoryChangeTrigger.Instance)listener.getCriterionInstance()).test(inventory))
+                    {
+                        if (list == null)
+                        {
+                            list = Lists.<ICriterionTrigger.Listener<InventoryChangeTrigger.Instance>>newArrayList();
+                        }
+
+                        list.add(listener);
+                    }
+                }
+
+                if (list != null)
+                {
+                    for (ICriterionTrigger.Listener<InventoryChangeTrigger.Instance> listener1 : list)
+                    {
+                        listener1.grantCriterion(this.playerAdvancements);
+                    }
+                }
+            }
+        }
+}

build/tmp/recompileMc/sources/net/minecraft/advancements/critereon/ItemDurabilityTrigger.java

@@ -0,0 +1,163 @@
+package net.minecraft.advancements.critereon;
+
+import com.google.common.collect.Lists;
+import com.google.common.collect.Maps;
+import com.google.common.collect.Sets;
+import com.google.gson.JsonDeserializationContext;
+import com.google.gson.JsonObject;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import net.minecraft.advancements.ICriterionTrigger;
+import net.minecraft.advancements.PlayerAdvancements;
+import net.minecraft.entity.player.EntityPlayerMP;
+import net.minecraft.item.ItemStack;
+import net.minecraft.util.ResourceLocation;
+
+public class ItemDurabilityTrigger implements ICriterionTrigger<ItemDurabilityTrigger.Instance>
+{
+    private static final ResourceLocation ID = new ResourceLocation("item_durability_changed");
+    private final Map<PlayerAdvancements, ItemDurabilityTrigger.Listeners> listeners = Maps.<PlayerAdvancements, ItemDurabilityTrigger.Listeners>newHashMap();
+
+    public ResourceLocation getId()
+    {
+        return ID;
+    }
+
+    public void addListener(PlayerAdvancements playerAdvancementsIn, ICriterionTrigger.Listener<ItemDurabilityTrigger.Instance> listener)
+    {
+        ItemDurabilityTrigger.Listeners itemdurabilitytrigger$listeners = this.listeners.get(playerAdvancementsIn);
+
+        if (itemdurabilitytrigger$listeners == null)
+        {
+            itemdurabilitytrigger$listeners = new ItemDurabilityTrigger.Listeners(playerAdvancementsIn);
+            this.listeners.put(playerAdvancementsIn, itemdurabilitytrigger$listeners);
+        }
+
+        itemdurabilitytrigger$listeners.add(listener);
+    }
+
+    public void removeListener(PlayerAdvancements playerAdvancementsIn, ICriterionTrigger.Listener<ItemDurabilityTrigger.Instance> listener)
+    {
+        ItemDurabilityTrigger.Listeners itemdurabilitytrigger$listeners = this.listeners.get(playerAdvancementsIn);
+
+        if (itemdurabilitytrigger$listeners != null)
+        {
+            itemdurabilitytrigger$listeners.remove(listener);
+
+            if (itemdurabilitytrigger$listeners.isEmpty())
+            {
+                this.listeners.remove(playerAdvancementsIn);
+            }
+        }
+    }
+
+    public void removeAllListeners(PlayerAdvancements playerAdvancementsIn)
+    {
+        this.listeners.remove(playerAdvancementsIn);
+    }
+
+    /**
+     * Deserialize a ICriterionInstance of this trigger from the data in the JSON.
+     */
+    public ItemDurabilityTrigger.Instance deserializeInstance(JsonObject json, JsonDeserializationContext context)
+    {
+        ItemPredicate itempredicate = ItemPredicate.deserialize(json.get("item"));
+        MinMaxBounds minmaxbounds = MinMaxBounds.deserialize(json.get("durability"));
+        MinMaxBounds minmaxbounds1 = MinMaxBounds.deserialize(json.get("delta"));
+        return new ItemDurabilityTrigger.Instance(itempredicate, minmaxbounds, minmaxbounds1);
+    }
+
+    public void trigger(EntityPlayerMP player, ItemStack itemIn, int newDurability)
+    {
+        ItemDurabilityTrigger.Listeners itemdurabilitytrigger$listeners = this.listeners.get(player.getAdvancements());
+
+        if (itemdurabilitytrigger$listeners != null)
+        {
+            itemdurabilitytrigger$listeners.trigger(itemIn, newDurability);
+        }
+    }
+
+    public static class Instance extends AbstractCriterionInstance
+        {
+            private final ItemPredicate item;
+            private final MinMaxBounds durability;
+            private final MinMaxBounds delta;
+
+            public Instance(ItemPredicate item, MinMaxBounds durability, MinMaxBounds delta)
+            {
+                super(ItemDurabilityTrigger.ID);
+                this.item = item;
+                this.durability = durability;
+                this.delta = delta;
+            }
+
+            public boolean test(ItemStack item, int p_193197_2_)
+            {
+                if (!this.item.test(item))
+                {
+                    return false;
+                }
+                else if (!this.durability.test((float)(item.getMaxDamage() - p_193197_2_)))
+                {
+                    return false;
+                }
+                else
+                {
+                    return this.delta.test((float)(item.getItemDamage() - p_193197_2_));
+                }
+            }
+        }
+
+    static class Listeners
+        {
+            private final PlayerAdvancements playerAdvancements;
+            private final Set<ICriterionTrigger.Listener<ItemDurabilityTrigger.Instance>> listeners = Sets.<ICriterionTrigger.Listener<ItemDurabilityTrigger.Instance>>newHashSet();
+
+            public Listeners(PlayerAdvancements playerAdvancementsIn)
+            {
+                this.playerAdvancements = playerAdvancementsIn;
+            }
+
+            public boolean isEmpty()
+            {
+                return this.listeners.isEmpty();
+            }
+
+            public void add(ICriterionTrigger.Listener<ItemDurabilityTrigger.Instance> listener)
+            {
+                this.listeners.add(listener);
+            }
+
+            public void remove(ICriterionTrigger.Listener<ItemDurabilityTrigger.Instance> listener)
+            {
+                this.listeners.remove(listener);
+            }
+
+            public void trigger(ItemStack item, int newDurability)
+            {
+                List<ICriterionTrigger.Listener<ItemDurabilityTrigger.Instance>> list = null;
+
+                for (ICriterionTrigger.Listener<ItemDurabilityTrigger.Instance> listener : this.listeners)
+                {
+                    if (((ItemDurabilityTrigger.Instance)listener.getCriterionInstance()).test(item, newDurability))
+                    {
+                        if (list == null)
+                        {
+                            list = Lists.<ICriterionTrigger.Listener<ItemDurabilityTrigger.Instance>>newArrayList();
+                        }
+
+                        list.add(listener);
+                    }
+                }
+
+                if (list != null)
+                {
+                    for (ICriterionTrigger.Listener<ItemDurabilityTrigger.Instance> listener1 : list)
+                    {
+                        listener1.grantCriterion(this.playerAdvancements);
+                    }
+                }
+            }
+        }
+}

build/tmp/recompileMc/sources/net/minecraft/advancements/critereon/ItemPredicate.java

@@ -0,0 +1,173 @@
+package net.minecraft.advancements.critereon;
+
+import com.google.gson.JsonArray;
+import com.google.gson.JsonElement;
+import com.google.gson.JsonObject;
+import com.google.gson.JsonSyntaxException;
+import java.util.Map;
+import javax.annotation.Nullable;
+import net.minecraft.enchantment.Enchantment;
+import net.minecraft.enchantment.EnchantmentHelper;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+import net.minecraft.potion.PotionType;
+import net.minecraft.potion.PotionUtils;
+import net.minecraft.util.JsonUtils;
+import net.minecraft.util.ResourceLocation;
+
+public class ItemPredicate
+{
+    public static final ItemPredicate ANY = new ItemPredicate();
+    private final Item item;
+    private final Integer data;
+    private final MinMaxBounds count;
+    private final MinMaxBounds durability;
+    private final EnchantmentPredicate[] enchantments;
+    private final PotionType potion;
+    private final NBTPredicate nbt;
+
+    public ItemPredicate()
+    {
+        this.item = null;
+        this.data = null;
+        this.potion = null;
+        this.count = MinMaxBounds.UNBOUNDED;
+        this.durability = MinMaxBounds.UNBOUNDED;
+        this.enchantments = new EnchantmentPredicate[0];
+        this.nbt = NBTPredicate.ANY;
+    }
+
+    public ItemPredicate(@Nullable Item item, @Nullable Integer data, MinMaxBounds count, MinMaxBounds durability, EnchantmentPredicate[] enchantments, @Nullable PotionType potion, NBTPredicate nbt)
+    {
+        this.item = item;
+        this.data = data;
+        this.count = count;
+        this.durability = durability;
+        this.enchantments = enchantments;
+        this.potion = potion;
+        this.nbt = nbt;
+    }
+
+    public boolean test(ItemStack item)
+    {
+        if (this.item != null && item.getItem() != this.item)
+        {
+            return false;
+        }
+        else if (this.data != null && item.getMetadata() != this.data.intValue())
+        {
+            return false;
+        }
+        else if (!this.count.test((float)item.getCount()))
+        {
+            return false;
+        }
+        else if (this.durability != MinMaxBounds.UNBOUNDED && !item.isItemStackDamageable())
+        {
+            return false;
+        }
+        else if (!this.durability.test((float)(item.getMaxDamage() - item.getItemDamage())))
+        {
+            return false;
+        }
+        else if (!this.nbt.test(item))
+        {
+            return false;
+        }
+        else
+        {
+            Map<Enchantment, Integer> map = EnchantmentHelper.getEnchantments(item);
+
+            for (int i = 0; i < this.enchantments.length; ++i)
+            {
+                if (!this.enchantments[i].test(map))
+                {
+                    return false;
+                }
+            }
+
+            PotionType potiontype = PotionUtils.getPotionFromItem(item);
+
+            if (this.potion != null && this.potion != potiontype)
+            {
+                return false;
+            }
+            else
+            {
+                return true;
+            }
+        }
+    }
+
+    public static ItemPredicate deserialize(@Nullable JsonElement element)
+    {
+        if (element != null && !element.isJsonNull())
+        {
+            JsonObject jsonobject = JsonUtils.getJsonObject(element, "item");
+            if (jsonobject.has("type"))
+            {
+                 final ResourceLocation rl = new ResourceLocation(JsonUtils.getString(jsonobject, "type"));
+                 final Map<ResourceLocation, java.util.function.Function<JsonObject, ItemPredicate>> map = net.minecraftforge.advancements.critereon.ItemPredicates.getPredicates();
+                 if (map.containsKey(rl)) return map.get(rl).apply(jsonobject);
+                 else throw new JsonSyntaxException("There is no ItemPredicate of type "+rl);
+            }
+            MinMaxBounds minmaxbounds = MinMaxBounds.deserialize(jsonobject.get("count"));
+            MinMaxBounds minmaxbounds1 = MinMaxBounds.deserialize(jsonobject.get("durability"));
+            Integer integer = jsonobject.has("data") ? JsonUtils.getInt(jsonobject, "data") : null;
+            NBTPredicate nbtpredicate = NBTPredicate.deserialize(jsonobject.get("nbt"));
+            Item item = null;
+
+            if (jsonobject.has("item"))
+            {
+                ResourceLocation resourcelocation = new ResourceLocation(JsonUtils.getString(jsonobject, "item"));
+                item = Item.REGISTRY.getObject(resourcelocation);
+
+                if (item == null)
+                {
+                    throw new JsonSyntaxException("Unknown item id '" + resourcelocation + "'");
+                }
+            }
+
+            EnchantmentPredicate[] aenchantmentpredicate = EnchantmentPredicate.deserializeArray(jsonobject.get("enchantments"));
+            PotionType potiontype = null;
+
+            if (jsonobject.has("potion"))
+            {
+                ResourceLocation resourcelocation1 = new ResourceLocation(JsonUtils.getString(jsonobject, "potion"));
+
+                if (!PotionType.REGISTRY.containsKey(resourcelocation1))
+                {
+                    throw new JsonSyntaxException("Unknown potion '" + resourcelocation1 + "'");
+                }
+
+                potiontype = PotionType.REGISTRY.getObject(resourcelocation1);
+            }
+
+            return new ItemPredicate(item, integer, minmaxbounds, minmaxbounds1, aenchantmentpredicate, potiontype, nbtpredicate);
+        }
+        else
+        {
+            return ANY;
+        }
+    }
+
+    public static ItemPredicate[] deserializeArray(@Nullable JsonElement element)
+    {
+        if (element != null && !element.isJsonNull())
+        {
+            JsonArray jsonarray = JsonUtils.getJsonArray(element, "items");
+            ItemPredicate[] aitempredicate = new ItemPredicate[jsonarray.size()];
+
+            for (int i = 0; i < aitempredicate.length; ++i)
+            {
+                aitempredicate[i] = deserialize(jsonarray.get(i));
+            }
+
+            return aitempredicate;
+        }
+        else
+        {
+            return new ItemPredicate[0];
+        }
+    }
+}

build/tmp/recompileMc/sources/net/minecraft/advancements/critereon/KilledTrigger.java

@@ -0,0 +1,153 @@
+package net.minecraft.advancements.critereon;
+
+import com.google.common.collect.Lists;
+import com.google.common.collect.Maps;
+import com.google.common.collect.Sets;
+import com.google.gson.JsonDeserializationContext;
+import com.google.gson.JsonObject;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import net.minecraft.advancements.ICriterionTrigger;
+import net.minecraft.advancements.PlayerAdvancements;
+import net.minecraft.entity.Entity;
+import net.minecraft.entity.player.EntityPlayerMP;
+import net.minecraft.util.DamageSource;
+import net.minecraft.util.ResourceLocation;
+
+public class KilledTrigger implements ICriterionTrigger<KilledTrigger.Instance>
+{
+    private final Map<PlayerAdvancements, KilledTrigger.Listeners> listeners = Maps.<PlayerAdvancements, KilledTrigger.Listeners>newHashMap();
+    private final ResourceLocation id;
+
+    public KilledTrigger(ResourceLocation id)
+    {
+        this.id = id;
+    }
+
+    public ResourceLocation getId()
+    {
+        return this.id;
+    }
+
+    public void addListener(PlayerAdvancements playerAdvancementsIn, ICriterionTrigger.Listener<KilledTrigger.Instance> listener)
+    {
+        KilledTrigger.Listeners killedtrigger$listeners = this.listeners.get(playerAdvancementsIn);
+
+        if (killedtrigger$listeners == null)
+        {
+            killedtrigger$listeners = new KilledTrigger.Listeners(playerAdvancementsIn);
+            this.listeners.put(playerAdvancementsIn, killedtrigger$listeners);
+        }
+
+        killedtrigger$listeners.add(listener);
+    }
+
+    public void removeListener(PlayerAdvancements playerAdvancementsIn, ICriterionTrigger.Listener<KilledTrigger.Instance> listener)
+    {
+        KilledTrigger.Listeners killedtrigger$listeners = this.listeners.get(playerAdvancementsIn);
+
+        if (killedtrigger$listeners != null)
+        {
+            killedtrigger$listeners.remove(listener);
+
+            if (killedtrigger$listeners.isEmpty())
+            {
+                this.listeners.remove(playerAdvancementsIn);
+            }
+        }
+    }
+
+    public void removeAllListeners(PlayerAdvancements playerAdvancementsIn)
+    {
+        this.listeners.remove(playerAdvancementsIn);
+    }
+
+    /**
+     * Deserialize a ICriterionInstance of this trigger from the data in the JSON.
+     */
+    public KilledTrigger.Instance deserializeInstance(JsonObject json, JsonDeserializationContext context)
+    {
+        return new KilledTrigger.Instance(this.id, EntityPredicate.deserialize(json.get("entity")), DamageSourcePredicate.deserialize(json.get("killing_blow")));
+    }
+
+    public void trigger(EntityPlayerMP player, Entity entity, DamageSource source)
+    {
+        KilledTrigger.Listeners killedtrigger$listeners = this.listeners.get(player.getAdvancements());
+
+        if (killedtrigger$listeners != null)
+        {
+            killedtrigger$listeners.trigger(player, entity, source);
+        }
+    }
+
+    public static class Instance extends AbstractCriterionInstance
+        {
+            private final EntityPredicate entity;
+            private final DamageSourcePredicate killingBlow;
+
+            public Instance(ResourceLocation criterionIn, EntityPredicate entity, DamageSourcePredicate killingBlow)
+            {
+                super(criterionIn);
+                this.entity = entity;
+                this.killingBlow = killingBlow;
+            }
+
+            public boolean test(EntityPlayerMP player, Entity entity, DamageSource source)
+            {
+                return !this.killingBlow.test(player, source) ? false : this.entity.test(player, entity);
+            }
+        }
+
+    static class Listeners
+        {
+            private final PlayerAdvancements playerAdvancements;
+            private final Set<ICriterionTrigger.Listener<KilledTrigger.Instance>> listeners = Sets.<ICriterionTrigger.Listener<KilledTrigger.Instance>>newHashSet();
+
+            public Listeners(PlayerAdvancements playerAdvancementsIn)
+            {
+                this.playerAdvancements = playerAdvancementsIn;
+            }
+
+            public boolean isEmpty()
+            {
+                return this.listeners.isEmpty();
+            }
+
+            public void add(ICriterionTrigger.Listener<KilledTrigger.Instance> listener)
+            {
+                this.listeners.add(listener);
+            }
+
+            public void remove(ICriterionTrigger.Listener<KilledTrigger.Instance> listener)
+            {
+                this.listeners.remove(listener);
+            }
+
+            public void trigger(EntityPlayerMP player, Entity entity, DamageSource source)
+            {
+                List<ICriterionTrigger.Listener<KilledTrigger.Instance>> list = null;
+
+                for (ICriterionTrigger.Listener<KilledTrigger.Instance> listener : this.listeners)
+                {
+                    if (((KilledTrigger.Instance)listener.getCriterionInstance()).test(player, entity, source))
+                    {
+                        if (list == null)
+                        {
+                            list = Lists.<ICriterionTrigger.Listener<KilledTrigger.Instance>>newArrayList();
+                        }
+
+                        list.add(listener);
+                    }
+                }
+
+                if (list != null)
+                {
+                    for (ICriterionTrigger.Listener<KilledTrigger.Instance> listener1 : list)
+                    {
+                        listener1.grantCriterion(this.playerAdvancements);
+                    }
+                }
+            }
+        }
+}

build/tmp/recompileMc/sources/net/minecraft/advancements/critereon/LevitationTrigger.java

@@ -0,0 +1,156 @@
+package net.minecraft.advancements.critereon;
+
+import com.google.common.collect.Lists;
+import com.google.common.collect.Maps;
+import com.google.common.collect.Sets;
+import com.google.gson.JsonDeserializationContext;
+import com.google.gson.JsonObject;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import net.minecraft.advancements.ICriterionTrigger;
+import net.minecraft.advancements.PlayerAdvancements;
+import net.minecraft.entity.player.EntityPlayerMP;
+import net.minecraft.util.ResourceLocation;
+import net.minecraft.util.math.Vec3d;
+
+public class LevitationTrigger implements ICriterionTrigger<LevitationTrigger.Instance>
+{
+    private static final ResourceLocation ID = new ResourceLocation("levitation");
+    private final Map<PlayerAdvancements, LevitationTrigger.Listeners> listeners = Maps.<PlayerAdvancements, LevitationTrigger.Listeners>newHashMap();
+
+    public ResourceLocation getId()
+    {
+        return ID;
+    }
+
+    public void addListener(PlayerAdvancements playerAdvancementsIn, ICriterionTrigger.Listener<LevitationTrigger.Instance> listener)
+    {
+        LevitationTrigger.Listeners levitationtrigger$listeners = this.listeners.get(playerAdvancementsIn);
+
+        if (levitationtrigger$listeners == null)
+        {
+            levitationtrigger$listeners = new LevitationTrigger.Listeners(playerAdvancementsIn);
+            this.listeners.put(playerAdvancementsIn, levitationtrigger$listeners);
+        }
+
+        levitationtrigger$listeners.add(listener);
+    }
+
+    public void removeListener(PlayerAdvancements playerAdvancementsIn, ICriterionTrigger.Listener<LevitationTrigger.Instance> listener)
+    {
+        LevitationTrigger.Listeners levitationtrigger$listeners = this.listeners.get(playerAdvancementsIn);
+
+        if (levitationtrigger$listeners != null)
+        {
+            levitationtrigger$listeners.remove(listener);
+
+            if (levitationtrigger$listeners.isEmpty())
+            {
+                this.listeners.remove(playerAdvancementsIn);
+            }
+        }
+    }
+
+    public void removeAllListeners(PlayerAdvancements playerAdvancementsIn)
+    {
+        this.listeners.remove(playerAdvancementsIn);
+    }
+
+    /**
+     * Deserialize a ICriterionInstance of this trigger from the data in the JSON.
+     */
+    public LevitationTrigger.Instance deserializeInstance(JsonObject json, JsonDeserializationContext context)
+    {
+        DistancePredicate distancepredicate = DistancePredicate.deserialize(json.get("distance"));
+        MinMaxBounds minmaxbounds = MinMaxBounds.deserialize(json.get("duration"));
+        return new LevitationTrigger.Instance(distancepredicate, minmaxbounds);
+    }
+
+    public void trigger(EntityPlayerMP player, Vec3d startPos, int duration)
+    {
+        LevitationTrigger.Listeners levitationtrigger$listeners = this.listeners.get(player.getAdvancements());
+
+        if (levitationtrigger$listeners != null)
+        {
+            levitationtrigger$listeners.trigger(player, startPos, duration);
+        }
+    }
+
+    public static class Instance extends AbstractCriterionInstance
+        {
+            private final DistancePredicate distance;
+            private final MinMaxBounds duration;
+
+            public Instance(DistancePredicate distance, MinMaxBounds duration)
+            {
+                super(LevitationTrigger.ID);
+                this.distance = distance;
+                this.duration = duration;
+            }
+
+            public boolean test(EntityPlayerMP player, Vec3d startPos, int durationIn)
+            {
+                if (!this.distance.test(startPos.x, startPos.y, startPos.z, player.posX, player.posY, player.posZ))
+                {
+                    return false;
+                }
+                else
+                {
+                    return this.duration.test((float)durationIn);
+                }
+            }
+        }
+
+    static class Listeners
+        {
+            private final PlayerAdvancements playerAdvancements;
+            private final Set<ICriterionTrigger.Listener<LevitationTrigger.Instance>> listeners = Sets.<ICriterionTrigger.Listener<LevitationTrigger.Instance>>newHashSet();
+
+            public Listeners(PlayerAdvancements playerAdvancementsIn)
+            {
+                this.playerAdvancements = playerAdvancementsIn;
+            }
+
+            public boolean isEmpty()
+            {
+                return this.listeners.isEmpty();
+            }
+
+            public void add(ICriterionTrigger.Listener<LevitationTrigger.Instance> listener)
+            {
+                this.listeners.add(listener);
+            }
+
+            public void remove(ICriterionTrigger.Listener<LevitationTrigger.Instance> listener)
+            {
+                this.listeners.remove(listener);
+            }
+
+            public void trigger(EntityPlayerMP player, Vec3d startPos, int durationIn)
+            {
+                List<ICriterionTrigger.Listener<LevitationTrigger.Instance>> list = null;
+
+                for (ICriterionTrigger.Listener<LevitationTrigger.Instance> listener : this.listeners)
+                {
+                    if (((LevitationTrigger.Instance)listener.getCriterionInstance()).test(player, startPos, durationIn))
+                    {
+                        if (list == null)
+                        {
+                            list = Lists.<ICriterionTrigger.Listener<LevitationTrigger.Instance>>newArrayList();
+                        }
+
+                        list.add(listener);
+                    }
+                }
+
+                if (list != null)
+                {
+                    for (ICriterionTrigger.Listener<LevitationTrigger.Instance> listener1 : list)
+                    {
+                        listener1.grantCriterion(this.playerAdvancements);
+                    }
+                }
+            }
+        }
+}

build/tmp/recompileMc/sources/net/minecraft/advancements/critereon/LocationPredicate.java

@@ -0,0 +1,106 @@
+package net.minecraft.advancements.critereon;
+
+import com.google.gson.JsonElement;
+import com.google.gson.JsonObject;
+import com.google.gson.JsonSyntaxException;
+import javax.annotation.Nullable;
+import net.minecraft.util.JsonUtils;
+import net.minecraft.util.ResourceLocation;
+import net.minecraft.util.math.BlockPos;
+import net.minecraft.world.DimensionType;
+import net.minecraft.world.WorldServer;
+import net.minecraft.world.biome.Biome;
+
+public class LocationPredicate
+{
+    public static LocationPredicate ANY = new LocationPredicate(MinMaxBounds.UNBOUNDED, MinMaxBounds.UNBOUNDED, MinMaxBounds.UNBOUNDED, (Biome)null, (String)null, (DimensionType)null);
+    private final MinMaxBounds x;
+    private final MinMaxBounds y;
+    private final MinMaxBounds z;
+    @Nullable
+    final Biome biome;
+    @Nullable
+    private final String feature;
+    @Nullable
+    private final DimensionType dimension;
+
+    public LocationPredicate(MinMaxBounds x, MinMaxBounds y, MinMaxBounds z, @Nullable Biome biome, @Nullable String feature, @Nullable DimensionType dimension)
+    {
+        this.x = x;
+        this.y = y;
+        this.z = z;
+        this.biome = biome;
+        this.feature = feature;
+        this.dimension = dimension;
+    }
+
+    public boolean test(WorldServer world, double x, double y, double z)
+    {
+        return this.test(world, (float)x, (float)y, (float)z);
+    }
+
+    public boolean test(WorldServer world, float x, float y, float z)
+    {
+        if (!this.x.test(x))
+        {
+            return false;
+        }
+        else if (!this.y.test(y))
+        {
+            return false;
+        }
+        else if (!this.z.test(z))
+        {
+            return false;
+        }
+        else if (this.dimension != null && this.dimension != world.provider.getDimensionType())
+        {
+            return false;
+        }
+        else
+        {
+            BlockPos blockpos = new BlockPos((double)x, (double)y, (double)z);
+
+            if (this.biome != null && this.biome != world.getBiome(blockpos))
+            {
+                return false;
+            }
+            else
+            {
+                return this.feature == null || world.getChunkProvider().isInsideStructure(world, this.feature, blockpos);
+            }
+        }
+    }
+
+    public static LocationPredicate deserialize(@Nullable JsonElement element)
+    {
+        if (element != null && !element.isJsonNull())
+        {
+            JsonObject jsonobject = JsonUtils.getJsonObject(element, "location");
+            JsonObject jsonobject1 = JsonUtils.getJsonObject(jsonobject, "position", new JsonObject());
+            MinMaxBounds minmaxbounds = MinMaxBounds.deserialize(jsonobject1.get("x"));
+            MinMaxBounds minmaxbounds1 = MinMaxBounds.deserialize(jsonobject1.get("y"));
+            MinMaxBounds minmaxbounds2 = MinMaxBounds.deserialize(jsonobject1.get("z"));
+            DimensionType dimensiontype = jsonobject.has("dimension") ? DimensionType.byName(JsonUtils.getString(jsonobject, "dimension")) : null;
+            String s = jsonobject.has("feature") ? JsonUtils.getString(jsonobject, "feature") : null;
+            Biome biome = null;
+
+            if (jsonobject.has("biome"))
+            {
+                ResourceLocation resourcelocation = new ResourceLocation(JsonUtils.getString(jsonobject, "biome"));
+                biome = Biome.REGISTRY.getObject(resourcelocation);
+
+                if (biome == null)
+                {
+                    throw new JsonSyntaxException("Unknown biome '" + resourcelocation + "'");
+                }
+            }
+
+            return new LocationPredicate(minmaxbounds, minmaxbounds1, minmaxbounds2, biome, s, dimensiontype);
+        }
+        else
+        {
+            return ANY;
+        }
+    }
+}

build/tmp/recompileMc/sources/net/minecraft/advancements/critereon/MinMaxBounds.java

@@ -0,0 +1,66 @@
+package net.minecraft.advancements.critereon;
+
+import com.google.gson.JsonElement;
+import com.google.gson.JsonObject;
+import javax.annotation.Nullable;
+import net.minecraft.util.JsonUtils;
+
+public class MinMaxBounds
+{
+    public static final MinMaxBounds UNBOUNDED = new MinMaxBounds((Float)null, (Float)null);
+    private final Float min;
+    private final Float max;
+
+    public MinMaxBounds(@Nullable Float min, @Nullable Float max)
+    {
+        this.min = min;
+        this.max = max;
+    }
+
+    public boolean test(float value)
+    {
+        if (this.min != null && this.min.floatValue() > value)
+        {
+            return false;
+        }
+        else
+        {
+            return this.max == null || this.max.floatValue() >= value;
+        }
+    }
+
+    public boolean testSquare(double value)
+    {
+        if (this.min != null && (double)(this.min.floatValue() * this.min.floatValue()) > value)
+        {
+            return false;
+        }
+        else
+        {
+            return this.max == null || (double)(this.max.floatValue() * this.max.floatValue()) >= value;
+        }
+    }
+
+    public static MinMaxBounds deserialize(@Nullable JsonElement element)
+    {
+        if (element != null && !element.isJsonNull())
+        {
+            if (JsonUtils.isNumber(element))
+            {
+                float f2 = JsonUtils.getFloat(element, "value");
+                return new MinMaxBounds(f2, f2);
+            }
+            else
+            {
+                JsonObject jsonobject = JsonUtils.getJsonObject(element, "value");
+                Float f = jsonobject.has("min") ? JsonUtils.getFloat(jsonobject, "min") : null;
+                Float f1 = jsonobject.has("max") ? JsonUtils.getFloat(jsonobject, "max") : null;
+                return new MinMaxBounds(f, f1);
+            }
+        }
+        else
+        {
+            return UNBOUNDED;
+        }
+    }
+}

build/tmp/recompileMc/sources/net/minecraft/advancements/critereon/MobEffectsPredicate.java

@@ -0,0 +1,147 @@
+package net.minecraft.advancements.critereon;
+
+import com.google.common.collect.Maps;
+import com.google.gson.JsonElement;
+import com.google.gson.JsonObject;
+import com.google.gson.JsonSyntaxException;
+import java.util.Collections;
+import java.util.Map;
+import java.util.Map.Entry;
+import javax.annotation.Nullable;
+import net.minecraft.entity.Entity;
+import net.minecraft.entity.EntityLivingBase;
+import net.minecraft.potion.Potion;
+import net.minecraft.potion.PotionEffect;
+import net.minecraft.util.JsonUtils;
+import net.minecraft.util.ResourceLocation;
+
+public class MobEffectsPredicate
+{
+    /** The predicate that matches any set of effects. */
+    public static final MobEffectsPredicate ANY = new MobEffectsPredicate(Collections.emptyMap());
+    private final Map<Potion, MobEffectsPredicate.InstancePredicate> effects;
+
+    public MobEffectsPredicate(Map<Potion, MobEffectsPredicate.InstancePredicate> effects)
+    {
+        this.effects = effects;
+    }
+
+    public boolean test(Entity entityIn)
+    {
+        if (this == ANY)
+        {
+            return true;
+        }
+        else
+        {
+            return entityIn instanceof EntityLivingBase ? this.test(((EntityLivingBase)entityIn).getActivePotionMap()) : false;
+        }
+    }
+
+    public boolean test(EntityLivingBase entityIn)
+    {
+        return this == ANY ? true : this.test(entityIn.getActivePotionMap());
+    }
+
+    public boolean test(Map<Potion, PotionEffect> potions)
+    {
+        if (this == ANY)
+        {
+            return true;
+        }
+        else
+        {
+            for (Entry<Potion, MobEffectsPredicate.InstancePredicate> entry : this.effects.entrySet())
+            {
+                PotionEffect potioneffect = potions.get(entry.getKey());
+
+                if (!((MobEffectsPredicate.InstancePredicate)entry.getValue()).test(potioneffect))
+                {
+                    return false;
+                }
+            }
+
+            return true;
+        }
+    }
+
+    public static MobEffectsPredicate deserialize(@Nullable JsonElement element)
+    {
+        if (element != null && !element.isJsonNull())
+        {
+            JsonObject jsonobject = JsonUtils.getJsonObject(element, "effects");
+            Map<Potion, MobEffectsPredicate.InstancePredicate> map = Maps.<Potion, MobEffectsPredicate.InstancePredicate>newHashMap();
+
+            for (Entry<String, JsonElement> entry : jsonobject.entrySet())
+            {
+                ResourceLocation resourcelocation = new ResourceLocation(entry.getKey());
+                Potion potion = Potion.REGISTRY.getObject(resourcelocation);
+
+                if (potion == null)
+                {
+                    throw new JsonSyntaxException("Unknown effect '" + resourcelocation + "'");
+                }
+
+                MobEffectsPredicate.InstancePredicate mobeffectspredicate$instancepredicate = MobEffectsPredicate.InstancePredicate.deserialize(JsonUtils.getJsonObject(entry.getValue(), entry.getKey()));
+                map.put(potion, mobeffectspredicate$instancepredicate);
+            }
+
+            return new MobEffectsPredicate(map);
+        }
+        else
+        {
+            return ANY;
+        }
+    }
+
+    public static class InstancePredicate
+        {
+            private final MinMaxBounds amplifier;
+            private final MinMaxBounds duration;
+            @Nullable
+            private final Boolean ambient;
+            @Nullable
+            private final Boolean visible;
+
+            public InstancePredicate(MinMaxBounds amplifier, MinMaxBounds duration, @Nullable Boolean ambient, @Nullable Boolean visible)
+            {
+                this.amplifier = amplifier;
+                this.duration = duration;
+                this.ambient = ambient;
+                this.visible = visible;
+            }
+
+            public boolean test(@Nullable PotionEffect effect)
+            {
+                if (effect == null)
+                {
+                    return false;
+                }
+                else if (!this.amplifier.test((float)effect.getAmplifier()))
+                {
+                    return false;
+                }
+                else if (!this.duration.test((float)effect.getDuration()))
+                {
+                    return false;
+                }
+                else if (this.ambient != null && this.ambient.booleanValue() != effect.getIsAmbient())
+                {
+                    return false;
+                }
+                else
+                {
+                    return this.visible == null || this.visible.booleanValue() == effect.doesShowParticles();
+                }
+            }
+
+            public static MobEffectsPredicate.InstancePredicate deserialize(JsonObject object)
+            {
+                MinMaxBounds minmaxbounds = MinMaxBounds.deserialize(object.get("amplifier"));
+                MinMaxBounds minmaxbounds1 = MinMaxBounds.deserialize(object.get("duration"));
+                Boolean obool = object.has("ambient") ? JsonUtils.getBoolean(object, "ambient") : null;
+                Boolean obool1 = object.has("visible") ? JsonUtils.getBoolean(object, "visible") : null;
+                return new MobEffectsPredicate.InstancePredicate(minmaxbounds, minmaxbounds1, obool, obool1);
+            }
+        }
+}

build/tmp/recompileMc/sources/net/minecraft/advancements/critereon/NBTPredicate.java

@@ -0,0 +1,72 @@
+package net.minecraft.advancements.critereon;
+
+import com.google.gson.JsonElement;
+import com.google.gson.JsonSyntaxException;
+import javax.annotation.Nullable;
+import net.minecraft.command.CommandBase;
+import net.minecraft.entity.Entity;
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.JsonToNBT;
+import net.minecraft.nbt.NBTBase;
+import net.minecraft.nbt.NBTException;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.nbt.NBTUtil;
+import net.minecraft.util.JsonUtils;
+
+public class NBTPredicate
+{
+    /** The predicate that matches any NBT tag. */
+    public static final NBTPredicate ANY = new NBTPredicate((NBTTagCompound)null);
+    @Nullable
+    private final NBTTagCompound tag;
+
+    public NBTPredicate(@Nullable NBTTagCompound tag)
+    {
+        this.tag = tag;
+    }
+
+    public boolean test(ItemStack item)
+    {
+        return this == ANY ? true : this.test(item.getTagCompound());
+    }
+
+    public boolean test(Entity entityIn)
+    {
+        return this == ANY ? true : this.test(CommandBase.entityToNBT(entityIn));
+    }
+
+    public boolean test(@Nullable NBTBase nbt)
+    {
+        if (nbt == null)
+        {
+            return this == ANY;
+        }
+        else
+        {
+            return this.tag == null || NBTUtil.areNBTEquals(this.tag, nbt, true);
+        }
+    }
+
+    public static NBTPredicate deserialize(@Nullable JsonElement json)
+    {
+        if (json != null && !json.isJsonNull())
+        {
+            NBTTagCompound nbttagcompound;
+
+            try
+            {
+                nbttagcompound = JsonToNBT.getTagFromJson(JsonUtils.getString(json, "nbt"));
+            }
+            catch (NBTException nbtexception)
+            {
+                throw new JsonSyntaxException("Invalid nbt tag: " + nbtexception.getMessage());
+            }
+
+            return new NBTPredicate(nbttagcompound);
+        }
+        else
+        {
+            return ANY;
+        }
+    }
+}

build/tmp/recompileMc/sources/net/minecraft/advancements/critereon/NetherTravelTrigger.java

@@ -0,0 +1,164 @@
+package net.minecraft.advancements.critereon;
+
+import com.google.common.collect.Lists;
+import com.google.common.collect.Maps;
+import com.google.common.collect.Sets;
+import com.google.gson.JsonDeserializationContext;
+import com.google.gson.JsonObject;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import net.minecraft.advancements.ICriterionTrigger;
+import net.minecraft.advancements.PlayerAdvancements;
+import net.minecraft.entity.player.EntityPlayerMP;
+import net.minecraft.util.ResourceLocation;
+import net.minecraft.util.math.Vec3d;
+import net.minecraft.world.WorldServer;
+
+public class NetherTravelTrigger implements ICriterionTrigger<NetherTravelTrigger.Instance>
+{
+    private static final ResourceLocation ID = new ResourceLocation("nether_travel");
+    private final Map<PlayerAdvancements, NetherTravelTrigger.Listeners> listeners = Maps.<PlayerAdvancements, NetherTravelTrigger.Listeners>newHashMap();
+
+    public ResourceLocation getId()
+    {
+        return ID;
+    }
+
+    public void addListener(PlayerAdvancements playerAdvancementsIn, ICriterionTrigger.Listener<NetherTravelTrigger.Instance> listener)
+    {
+        NetherTravelTrigger.Listeners nethertraveltrigger$listeners = this.listeners.get(playerAdvancementsIn);
+
+        if (nethertraveltrigger$listeners == null)
+        {
+            nethertraveltrigger$listeners = new NetherTravelTrigger.Listeners(playerAdvancementsIn);
+            this.listeners.put(playerAdvancementsIn, nethertraveltrigger$listeners);
+        }
+
+        nethertraveltrigger$listeners.add(listener);
+    }
+
+    public void removeListener(PlayerAdvancements playerAdvancementsIn, ICriterionTrigger.Listener<NetherTravelTrigger.Instance> listener)
+    {
+        NetherTravelTrigger.Listeners nethertraveltrigger$listeners = this.listeners.get(playerAdvancementsIn);
+
+        if (nethertraveltrigger$listeners != null)
+        {
+            nethertraveltrigger$listeners.remove(listener);
+
+            if (nethertraveltrigger$listeners.isEmpty())
+            {
+                this.listeners.remove(playerAdvancementsIn);
+            }
+        }
+    }
+
+    public void removeAllListeners(PlayerAdvancements playerAdvancementsIn)
+    {
+        this.listeners.remove(playerAdvancementsIn);
+    }
+
+    /**
+     * Deserialize a ICriterionInstance of this trigger from the data in the JSON.
+     */
+    public NetherTravelTrigger.Instance deserializeInstance(JsonObject json, JsonDeserializationContext context)
+    {
+        LocationPredicate locationpredicate = LocationPredicate.deserialize(json.get("entered"));
+        LocationPredicate locationpredicate1 = LocationPredicate.deserialize(json.get("exited"));
+        DistancePredicate distancepredicate = DistancePredicate.deserialize(json.get("distance"));
+        return new NetherTravelTrigger.Instance(locationpredicate, locationpredicate1, distancepredicate);
+    }
+
+    public void trigger(EntityPlayerMP player, Vec3d enteredNetherPosition)
+    {
+        NetherTravelTrigger.Listeners nethertraveltrigger$listeners = this.listeners.get(player.getAdvancements());
+
+        if (nethertraveltrigger$listeners != null)
+        {
+            nethertraveltrigger$listeners.trigger(player.getServerWorld(), enteredNetherPosition, player.posX, player.posY, player.posZ);
+        }
+    }
+
+    public static class Instance extends AbstractCriterionInstance
+        {
+            private final LocationPredicate entered;
+            private final LocationPredicate exited;
+            private final DistancePredicate distance;
+
+            public Instance(LocationPredicate enteredIn, LocationPredicate exitedIn, DistancePredicate distanceIn)
+            {
+                super(NetherTravelTrigger.ID);
+                this.entered = enteredIn;
+                this.exited = exitedIn;
+                this.distance = distanceIn;
+            }
+
+            public boolean test(WorldServer world, Vec3d enteredNetherPosition, double x, double y, double z)
+            {
+                if (!this.entered.test(world, enteredNetherPosition.x, enteredNetherPosition.y, enteredNetherPosition.z))
+                {
+                    return false;
+                }
+                else if (!this.exited.test(world, x, y, z))
+                {
+                    return false;
+                }
+                else
+                {
+                    return this.distance.test(enteredNetherPosition.x, enteredNetherPosition.y, enteredNetherPosition.z, x, y, z);
+                }
+            }
+        }
+
+    static class Listeners
+        {
+            private final PlayerAdvancements playerAdvancements;
+            private final Set<ICriterionTrigger.Listener<NetherTravelTrigger.Instance>> listeners = Sets.<ICriterionTrigger.Listener<NetherTravelTrigger.Instance>>newHashSet();
+
+            public Listeners(PlayerAdvancements playerAdvancementsIn)
+            {
+                this.playerAdvancements = playerAdvancementsIn;
+            }
+
+            public boolean isEmpty()
+            {
+                return this.listeners.isEmpty();
+            }
+
+            public void add(ICriterionTrigger.Listener<NetherTravelTrigger.Instance> listener)
+            {
+                this.listeners.add(listener);
+            }
+
+            public void remove(ICriterionTrigger.Listener<NetherTravelTrigger.Instance> listener)
+            {
+                this.listeners.remove(listener);
+            }
+
+            public void trigger(WorldServer world, Vec3d enteredNetherPosition, double x, double y, double z)
+            {
+                List<ICriterionTrigger.Listener<NetherTravelTrigger.Instance>> list = null;
+
+                for (ICriterionTrigger.Listener<NetherTravelTrigger.Instance> listener : this.listeners)
+                {
+                    if (((NetherTravelTrigger.Instance)listener.getCriterionInstance()).test(world, enteredNetherPosition, x, y, z))
+                    {
+                        if (list == null)
+                        {
+                            list = Lists.<ICriterionTrigger.Listener<NetherTravelTrigger.Instance>>newArrayList();
+                        }
+
+                        list.add(listener);
+                    }
+                }
+
+                if (list != null)
+                {
+                    for (ICriterionTrigger.Listener<NetherTravelTrigger.Instance> listener1 : list)
+                    {
+                        listener1.grantCriterion(this.playerAdvancements);
+                    }
+                }
+            }
+        }
+}

build/tmp/recompileMc/sources/net/minecraft/advancements/critereon/PlacedBlockTrigger.java

@@ -0,0 +1,242 @@
+package net.minecraft.advancements.critereon;
+
+import com.google.common.base.Optional;
+import com.google.common.collect.Lists;
+import com.google.common.collect.Maps;
+import com.google.common.collect.Sets;
+import com.google.gson.JsonDeserializationContext;
+import com.google.gson.JsonElement;
+import com.google.gson.JsonObject;
+import com.google.gson.JsonSyntaxException;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.Map.Entry;
+import javax.annotation.Nullable;
+import net.minecraft.advancements.ICriterionTrigger;
+import net.minecraft.advancements.PlayerAdvancements;
+import net.minecraft.block.Block;
+import net.minecraft.block.properties.IProperty;
+import net.minecraft.block.state.BlockStateContainer;
+import net.minecraft.block.state.IBlockState;
+import net.minecraft.entity.player.EntityPlayerMP;
+import net.minecraft.item.ItemStack;
+import net.minecraft.util.JsonUtils;
+import net.minecraft.util.ResourceLocation;
+import net.minecraft.util.math.BlockPos;
+import net.minecraft.world.WorldServer;
+
+public class PlacedBlockTrigger implements ICriterionTrigger<PlacedBlockTrigger.Instance>
+{
+    private static final ResourceLocation ID = new ResourceLocation("placed_block");
+    private final Map<PlayerAdvancements, PlacedBlockTrigger.Listeners> listeners = Maps.<PlayerAdvancements, PlacedBlockTrigger.Listeners>newHashMap();
+
+    public ResourceLocation getId()
+    {
+        return ID;
+    }
+
+    public void addListener(PlayerAdvancements playerAdvancementsIn, ICriterionTrigger.Listener<PlacedBlockTrigger.Instance> listener)
+    {
+        PlacedBlockTrigger.Listeners placedblocktrigger$listeners = this.listeners.get(playerAdvancementsIn);
+
+        if (placedblocktrigger$listeners == null)
+        {
+            placedblocktrigger$listeners = new PlacedBlockTrigger.Listeners(playerAdvancementsIn);
+            this.listeners.put(playerAdvancementsIn, placedblocktrigger$listeners);
+        }
+
+        placedblocktrigger$listeners.add(listener);
+    }
+
+    public void removeListener(PlayerAdvancements playerAdvancementsIn, ICriterionTrigger.Listener<PlacedBlockTrigger.Instance> listener)
+    {
+        PlacedBlockTrigger.Listeners placedblocktrigger$listeners = this.listeners.get(playerAdvancementsIn);
+
+        if (placedblocktrigger$listeners != null)
+        {
+            placedblocktrigger$listeners.remove(listener);
+
+            if (placedblocktrigger$listeners.isEmpty())
+            {
+                this.listeners.remove(playerAdvancementsIn);
+            }
+        }
+    }
+
+    public void removeAllListeners(PlayerAdvancements playerAdvancementsIn)
+    {
+        this.listeners.remove(playerAdvancementsIn);
+    }
+
+    /**
+     * Deserialize a ICriterionInstance of this trigger from the data in the JSON.
+     */
+    public PlacedBlockTrigger.Instance deserializeInstance(JsonObject json, JsonDeserializationContext context)
+    {
+        Block block = null;
+
+        if (json.has("block"))
+        {
+            ResourceLocation resourcelocation = new ResourceLocation(JsonUtils.getString(json, "block"));
+
+            if (!Block.REGISTRY.containsKey(resourcelocation))
+            {
+                throw new JsonSyntaxException("Unknown block type '" + resourcelocation + "'");
+            }
+
+            block = Block.REGISTRY.getObject(resourcelocation);
+        }
+
+        Map < IProperty<?>, Object > map = null;
+
+        if (json.has("state"))
+        {
+            if (block == null)
+            {
+                throw new JsonSyntaxException("Can't define block state without a specific block type");
+            }
+
+            BlockStateContainer blockstatecontainer = block.getBlockState();
+
+            for (Entry<String, JsonElement> entry : JsonUtils.getJsonObject(json, "state").entrySet())
+            {
+                IProperty<?> iproperty = blockstatecontainer.getProperty(entry.getKey());
+
+                if (iproperty == null)
+                {
+                    throw new JsonSyntaxException("Unknown block state property '" + (String)entry.getKey() + "' for block '" + Block.REGISTRY.getNameForObject(block) + "'");
+                }
+
+                String s = JsonUtils.getString(entry.getValue(), entry.getKey());
+                Optional<?> optional = iproperty.parseValue(s);
+
+                if (!optional.isPresent())
+                {
+                    throw new JsonSyntaxException("Invalid block state value '" + s + "' for property '" + (String)entry.getKey() + "' on block '" + Block.REGISTRY.getNameForObject(block) + "'");
+                }
+
+                if (map == null)
+                {
+                    map = Maps. < IProperty<?>, Object > newHashMap();
+                }
+
+                map.put(iproperty, optional.get());
+            }
+        }
+
+        LocationPredicate locationpredicate = LocationPredicate.deserialize(json.get("location"));
+        ItemPredicate itempredicate = ItemPredicate.deserialize(json.get("item"));
+        return new PlacedBlockTrigger.Instance(block, map, locationpredicate, itempredicate);
+    }
+
+    public void trigger(EntityPlayerMP player, BlockPos pos, ItemStack item)
+    {
+        IBlockState iblockstate = player.world.getBlockState(pos);
+        PlacedBlockTrigger.Listeners placedblocktrigger$listeners = this.listeners.get(player.getAdvancements());
+
+        if (placedblocktrigger$listeners != null)
+        {
+            placedblocktrigger$listeners.trigger(iblockstate, pos, player.getServerWorld(), item);
+        }
+    }
+
+    public static class Instance extends AbstractCriterionInstance
+        {
+            private final Block block;
+            private final Map < IProperty<?>, Object > properties;
+            private final LocationPredicate location;
+            private final ItemPredicate item;
+
+            public Instance(@Nullable Block block, @Nullable Map < IProperty<?>, Object > propertiesIn, LocationPredicate locationIn, ItemPredicate itemIn)
+            {
+                super(PlacedBlockTrigger.ID);
+                this.block = block;
+                this.properties = propertiesIn;
+                this.location = locationIn;
+                this.item = itemIn;
+            }
+
+            public boolean test(IBlockState state, BlockPos pos, WorldServer world, ItemStack item)
+            {
+                if (this.block != null && state.getBlock() != this.block)
+                {
+                    return false;
+                }
+                else
+                {
+                    if (this.properties != null)
+                    {
+                        for (Entry < IProperty<?>, Object > entry : this.properties.entrySet())
+                        {
+                            if (state.getValue(entry.getKey()) != entry.getValue())
+                            {
+                                return false;
+                            }
+                        }
+                    }
+
+                    if (!this.location.test(world, (float)pos.getX(), (float)pos.getY(), (float)pos.getZ()))
+                    {
+                        return false;
+                    }
+                    else
+                    {
+                        return this.item.test(item);
+                    }
+                }
+            }
+        }
+
+    static class Listeners
+        {
+            private final PlayerAdvancements playerAdvancements;
+            private final Set<ICriterionTrigger.Listener<PlacedBlockTrigger.Instance>> listeners = Sets.<ICriterionTrigger.Listener<PlacedBlockTrigger.Instance>>newHashSet();
+
+            public Listeners(PlayerAdvancements playerAdvancementsIn)
+            {
+                this.playerAdvancements = playerAdvancementsIn;
+            }
+
+            public boolean isEmpty()
+            {
+                return this.listeners.isEmpty();
+            }
+
+            public void add(ICriterionTrigger.Listener<PlacedBlockTrigger.Instance> listener)
+            {
+                this.listeners.add(listener);
+            }
+
+            public void remove(ICriterionTrigger.Listener<PlacedBlockTrigger.Instance> listener)
+            {
+                this.listeners.remove(listener);
+            }
+
+            public void trigger(IBlockState state, BlockPos pos, WorldServer world, ItemStack item)
+            {
+                List<ICriterionTrigger.Listener<PlacedBlockTrigger.Instance>> list = null;
+
+                for (ICriterionTrigger.Listener<PlacedBlockTrigger.Instance> listener : this.listeners)
+                {
+                    if (((PlacedBlockTrigger.Instance)listener.getCriterionInstance()).test(state, pos, world, item))
+                    {
+                        if (list == null)
+                        {
+                            list = Lists.<ICriterionTrigger.Listener<PlacedBlockTrigger.Instance>>newArrayList();
+                        }
+
+                        list.add(listener);
+                    }
+                }
+
+                if (list != null)
+                {
+                    for (ICriterionTrigger.Listener<PlacedBlockTrigger.Instance> listener1 : list)
+                    {
+                        listener1.grantCriterion(this.playerAdvancements);
+                    }
+                }
+            }
+        }
+}

build/tmp/recompileMc/sources/net/minecraft/advancements/critereon/PlayerHurtEntityTrigger.java

@@ -0,0 +1,157 @@
+package net.minecraft.advancements.critereon;
+
+import com.google.common.collect.Lists;
+import com.google.common.collect.Maps;
+import com.google.common.collect.Sets;
+import com.google.gson.JsonDeserializationContext;
+import com.google.gson.JsonObject;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import net.minecraft.advancements.ICriterionTrigger;
+import net.minecraft.advancements.PlayerAdvancements;
+import net.minecraft.entity.Entity;
+import net.minecraft.entity.player.EntityPlayerMP;
+import net.minecraft.util.DamageSource;
+import net.minecraft.util.ResourceLocation;
+
+public class PlayerHurtEntityTrigger implements ICriterionTrigger<PlayerHurtEntityTrigger.Instance>
+{
+    private static final ResourceLocation ID = new ResourceLocation("player_hurt_entity");
+    private final Map<PlayerAdvancements, PlayerHurtEntityTrigger.Listeners> listeners = Maps.<PlayerAdvancements, PlayerHurtEntityTrigger.Listeners>newHashMap();
+
+    public ResourceLocation getId()
+    {
+        return ID;
+    }
+
+    public void addListener(PlayerAdvancements playerAdvancementsIn, ICriterionTrigger.Listener<PlayerHurtEntityTrigger.Instance> listener)
+    {
+        PlayerHurtEntityTrigger.Listeners playerhurtentitytrigger$listeners = this.listeners.get(playerAdvancementsIn);
+
+        if (playerhurtentitytrigger$listeners == null)
+        {
+            playerhurtentitytrigger$listeners = new PlayerHurtEntityTrigger.Listeners(playerAdvancementsIn);
+            this.listeners.put(playerAdvancementsIn, playerhurtentitytrigger$listeners);
+        }
+
+        playerhurtentitytrigger$listeners.add(listener);
+    }
+
+    public void removeListener(PlayerAdvancements playerAdvancementsIn, ICriterionTrigger.Listener<PlayerHurtEntityTrigger.Instance> listener)
+    {
+        PlayerHurtEntityTrigger.Listeners playerhurtentitytrigger$listeners = this.listeners.get(playerAdvancementsIn);
+
+        if (playerhurtentitytrigger$listeners != null)
+        {
+            playerhurtentitytrigger$listeners.remove(listener);
+
+            if (playerhurtentitytrigger$listeners.isEmpty())
+            {
+                this.listeners.remove(playerAdvancementsIn);
+            }
+        }
+    }
+
+    public void removeAllListeners(PlayerAdvancements playerAdvancementsIn)
+    {
+        this.listeners.remove(playerAdvancementsIn);
+    }
+
+    /**
+     * Deserialize a ICriterionInstance of this trigger from the data in the JSON.
+     */
+    public PlayerHurtEntityTrigger.Instance deserializeInstance(JsonObject json, JsonDeserializationContext context)
+    {
+        DamagePredicate damagepredicate = DamagePredicate.deserialize(json.get("damage"));
+        EntityPredicate entitypredicate = EntityPredicate.deserialize(json.get("entity"));
+        return new PlayerHurtEntityTrigger.Instance(damagepredicate, entitypredicate);
+    }
+
+    public void trigger(EntityPlayerMP player, Entity entityIn, DamageSource source, float amountDealt, float amountTaken, boolean blocked)
+    {
+        PlayerHurtEntityTrigger.Listeners playerhurtentitytrigger$listeners = this.listeners.get(player.getAdvancements());
+
+        if (playerhurtentitytrigger$listeners != null)
+        {
+            playerhurtentitytrigger$listeners.trigger(player, entityIn, source, amountDealt, amountTaken, blocked);
+        }
+    }
+
+    public static class Instance extends AbstractCriterionInstance
+        {
+            private final DamagePredicate damage;
+            private final EntityPredicate entity;
+
+            public Instance(DamagePredicate damage, EntityPredicate entity)
+            {
+                super(PlayerHurtEntityTrigger.ID);
+                this.damage = damage;
+                this.entity = entity;
+            }
+
+            public boolean test(EntityPlayerMP player, Entity entity, DamageSource source, float dealt, float taken, boolean blocked)
+            {
+                if (!this.damage.test(player, source, dealt, taken, blocked))
+                {
+                    return false;
+                }
+                else
+                {
+                    return this.entity.test(player, entity);
+                }
+            }
+        }
+
+    static class Listeners
+        {
+            private final PlayerAdvancements playerAdvancements;
+            private final Set<ICriterionTrigger.Listener<PlayerHurtEntityTrigger.Instance>> listeners = Sets.<ICriterionTrigger.Listener<PlayerHurtEntityTrigger.Instance>>newHashSet();
+
+            public Listeners(PlayerAdvancements playerAdvancementsIn)
+            {
+                this.playerAdvancements = playerAdvancementsIn;
+            }
+
+            public boolean isEmpty()
+            {
+                return this.listeners.isEmpty();
+            }
+
+            public void add(ICriterionTrigger.Listener<PlayerHurtEntityTrigger.Instance> listener)
+            {
+                this.listeners.add(listener);
+            }
+
+            public void remove(ICriterionTrigger.Listener<PlayerHurtEntityTrigger.Instance> listener)
+            {
+                this.listeners.remove(listener);
+            }
+
+            public void trigger(EntityPlayerMP player, Entity entity, DamageSource source, float dealt, float taken, boolean blocked)
+            {
+                List<ICriterionTrigger.Listener<PlayerHurtEntityTrigger.Instance>> list = null;
+
+                for (ICriterionTrigger.Listener<PlayerHurtEntityTrigger.Instance> listener : this.listeners)
+                {
+                    if (((PlayerHurtEntityTrigger.Instance)listener.getCriterionInstance()).test(player, entity, source, dealt, taken, blocked))
+                    {
+                        if (list == null)
+                        {
+                            list = Lists.<ICriterionTrigger.Listener<PlayerHurtEntityTrigger.Instance>>newArrayList();
+                        }
+
+                        list.add(listener);
+                    }
+                }
+
+                if (list != null)
+                {
+                    for (ICriterionTrigger.Listener<PlayerHurtEntityTrigger.Instance> listener1 : list)
+                    {
+                        listener1.grantCriterion(this.playerAdvancements);
+                    }
+                }
+            }
+        }
+}

build/tmp/recompileMc/sources/net/minecraft/advancements/critereon/PositionTrigger.java

@@ -0,0 +1,151 @@
+package net.minecraft.advancements.critereon;
+
+import com.google.common.collect.Lists;
+import com.google.common.collect.Maps;
+import com.google.common.collect.Sets;
+import com.google.gson.JsonDeserializationContext;
+import com.google.gson.JsonObject;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import net.minecraft.advancements.ICriterionTrigger;
+import net.minecraft.advancements.PlayerAdvancements;
+import net.minecraft.entity.player.EntityPlayerMP;
+import net.minecraft.util.ResourceLocation;
+import net.minecraft.world.WorldServer;
+
+public class PositionTrigger implements ICriterionTrigger<PositionTrigger.Instance>
+{
+    private final ResourceLocation id;
+    private final Map<PlayerAdvancements, PositionTrigger.Listeners> listeners = Maps.<PlayerAdvancements, PositionTrigger.Listeners>newHashMap();
+
+    public PositionTrigger(ResourceLocation id)
+    {
+        this.id = id;
+    }
+
+    public ResourceLocation getId()
+    {
+        return this.id;
+    }
+
+    public void addListener(PlayerAdvancements playerAdvancementsIn, ICriterionTrigger.Listener<PositionTrigger.Instance> listener)
+    {
+        PositionTrigger.Listeners positiontrigger$listeners = this.listeners.get(playerAdvancementsIn);
+
+        if (positiontrigger$listeners == null)
+        {
+            positiontrigger$listeners = new PositionTrigger.Listeners(playerAdvancementsIn);
+            this.listeners.put(playerAdvancementsIn, positiontrigger$listeners);
+        }
+
+        positiontrigger$listeners.add(listener);
+    }
+
+    public void removeListener(PlayerAdvancements playerAdvancementsIn, ICriterionTrigger.Listener<PositionTrigger.Instance> listener)
+    {
+        PositionTrigger.Listeners positiontrigger$listeners = this.listeners.get(playerAdvancementsIn);
+
+        if (positiontrigger$listeners != null)
+        {
+            positiontrigger$listeners.remove(listener);
+
+            if (positiontrigger$listeners.isEmpty())
+            {
+                this.listeners.remove(playerAdvancementsIn);
+            }
+        }
+    }
+
+    public void removeAllListeners(PlayerAdvancements playerAdvancementsIn)
+    {
+        this.listeners.remove(playerAdvancementsIn);
+    }
+
+    /**
+     * Deserialize a ICriterionInstance of this trigger from the data in the JSON.
+     */
+    public PositionTrigger.Instance deserializeInstance(JsonObject json, JsonDeserializationContext context)
+    {
+        LocationPredicate locationpredicate = LocationPredicate.deserialize(json);
+        return new PositionTrigger.Instance(this.id, locationpredicate);
+    }
+
+    public void trigger(EntityPlayerMP player)
+    {
+        PositionTrigger.Listeners positiontrigger$listeners = this.listeners.get(player.getAdvancements());
+
+        if (positiontrigger$listeners != null)
+        {
+            positiontrigger$listeners.trigger(player.getServerWorld(), player.posX, player.posY, player.posZ);
+        }
+    }
+
+    public static class Instance extends AbstractCriterionInstance
+        {
+            private final LocationPredicate location;
+
+            public Instance(ResourceLocation criterionIn, LocationPredicate location)
+            {
+                super(criterionIn);
+                this.location = location;
+            }
+
+            public boolean test(WorldServer world, double x, double y, double z)
+            {
+                return this.location.test(world, x, y, z);
+            }
+        }
+
+    static class Listeners
+        {
+            private final PlayerAdvancements playerAdvancements;
+            private final Set<ICriterionTrigger.Listener<PositionTrigger.Instance>> listeners = Sets.<ICriterionTrigger.Listener<PositionTrigger.Instance>>newHashSet();
+
+            public Listeners(PlayerAdvancements playerAdvancementsIn)
+            {
+                this.playerAdvancements = playerAdvancementsIn;
+            }
+
+            public boolean isEmpty()
+            {
+                return this.listeners.isEmpty();
+            }
+
+            public void add(ICriterionTrigger.Listener<PositionTrigger.Instance> listener)
+            {
+                this.listeners.add(listener);
+            }
+
+            public void remove(ICriterionTrigger.Listener<PositionTrigger.Instance> listener)
+            {
+                this.listeners.remove(listener);
+            }
+
+            public void trigger(WorldServer world, double x, double y, double z)
+            {
+                List<ICriterionTrigger.Listener<PositionTrigger.Instance>> list = null;
+
+                for (ICriterionTrigger.Listener<PositionTrigger.Instance> listener : this.listeners)
+                {
+                    if (((PositionTrigger.Instance)listener.getCriterionInstance()).test(world, x, y, z))
+                    {
+                        if (list == null)
+                        {
+                            list = Lists.<ICriterionTrigger.Listener<PositionTrigger.Instance>>newArrayList();
+                        }
+
+                        list.add(listener);
+                    }
+                }
+
+                if (list != null)
+                {
+                    for (ICriterionTrigger.Listener<PositionTrigger.Instance> listener1 : list)
+                    {
+                        listener1.grantCriterion(this.playerAdvancements);
+                    }
+                }
+            }
+        }
+}

build/tmp/recompileMc/sources/net/minecraft/advancements/critereon/RecipeUnlockedTrigger.java

@@ -0,0 +1,158 @@
+package net.minecraft.advancements.critereon;
+
+import com.google.common.collect.Lists;
+import com.google.common.collect.Maps;
+import com.google.common.collect.Sets;
+import com.google.gson.JsonDeserializationContext;
+import com.google.gson.JsonObject;
+import com.google.gson.JsonSyntaxException;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import net.minecraft.advancements.ICriterionTrigger;
+import net.minecraft.advancements.PlayerAdvancements;
+import net.minecraft.entity.player.EntityPlayerMP;
+import net.minecraft.item.crafting.CraftingManager;
+import net.minecraft.item.crafting.IRecipe;
+import net.minecraft.util.JsonUtils;
+import net.minecraft.util.ResourceLocation;
+
+public class RecipeUnlockedTrigger implements ICriterionTrigger<RecipeUnlockedTrigger.Instance>
+{
+    private static final ResourceLocation ID = new ResourceLocation("recipe_unlocked");
+    private final Map<PlayerAdvancements, RecipeUnlockedTrigger.Listeners> listeners = Maps.<PlayerAdvancements, RecipeUnlockedTrigger.Listeners>newHashMap();
+
+    public ResourceLocation getId()
+    {
+        return ID;
+    }
+
+    public void addListener(PlayerAdvancements playerAdvancementsIn, ICriterionTrigger.Listener<RecipeUnlockedTrigger.Instance> listener)
+    {
+        RecipeUnlockedTrigger.Listeners recipeunlockedtrigger$listeners = this.listeners.get(playerAdvancementsIn);
+
+        if (recipeunlockedtrigger$listeners == null)
+        {
+            recipeunlockedtrigger$listeners = new RecipeUnlockedTrigger.Listeners(playerAdvancementsIn);
+            this.listeners.put(playerAdvancementsIn, recipeunlockedtrigger$listeners);
+        }
+
+        recipeunlockedtrigger$listeners.add(listener);
+    }
+
+    public void removeListener(PlayerAdvancements playerAdvancementsIn, ICriterionTrigger.Listener<RecipeUnlockedTrigger.Instance> listener)
+    {
+        RecipeUnlockedTrigger.Listeners recipeunlockedtrigger$listeners = this.listeners.get(playerAdvancementsIn);
+
+        if (recipeunlockedtrigger$listeners != null)
+        {
+            recipeunlockedtrigger$listeners.remove(listener);
+
+            if (recipeunlockedtrigger$listeners.isEmpty())
+            {
+                this.listeners.remove(playerAdvancementsIn);
+            }
+        }
+    }
+
+    public void removeAllListeners(PlayerAdvancements playerAdvancementsIn)
+    {
+        this.listeners.remove(playerAdvancementsIn);
+    }
+
+    /**
+     * Deserialize a ICriterionInstance of this trigger from the data in the JSON.
+     */
+    public RecipeUnlockedTrigger.Instance deserializeInstance(JsonObject json, JsonDeserializationContext context)
+    {
+        ResourceLocation resourcelocation = new ResourceLocation(JsonUtils.getString(json, "recipe"));
+        IRecipe irecipe = CraftingManager.getRecipe(resourcelocation);
+
+        if (irecipe == null)
+        {
+            throw new JsonSyntaxException("Unknown recipe '" + resourcelocation + "'");
+        }
+        else
+        {
+            return new RecipeUnlockedTrigger.Instance(irecipe);
+        }
+    }
+
+    public void trigger(EntityPlayerMP player, IRecipe recipe)
+    {
+        RecipeUnlockedTrigger.Listeners recipeunlockedtrigger$listeners = this.listeners.get(player.getAdvancements());
+
+        if (recipeunlockedtrigger$listeners != null)
+        {
+            recipeunlockedtrigger$listeners.trigger(recipe);
+        }
+    }
+
+    public static class Instance extends AbstractCriterionInstance
+        {
+            private final IRecipe recipe;
+
+            public Instance(IRecipe recipe)
+            {
+                super(RecipeUnlockedTrigger.ID);
+                this.recipe = recipe;
+            }
+
+            public boolean test(IRecipe recipe)
+            {
+                return this.recipe == recipe;
+            }
+        }
+
+    static class Listeners
+        {
+            private final PlayerAdvancements playerAdvancements;
+            private final Set<ICriterionTrigger.Listener<RecipeUnlockedTrigger.Instance>> listeners = Sets.<ICriterionTrigger.Listener<RecipeUnlockedTrigger.Instance>>newHashSet();
+
+            public Listeners(PlayerAdvancements playerAdvancementsIn)
+            {
+                this.playerAdvancements = playerAdvancementsIn;
+            }
+
+            public boolean isEmpty()
+            {
+                return this.listeners.isEmpty();
+            }
+
+            public void add(ICriterionTrigger.Listener<RecipeUnlockedTrigger.Instance> listener)
+            {
+                this.listeners.add(listener);
+            }
+
+            public void remove(ICriterionTrigger.Listener<RecipeUnlockedTrigger.Instance> listener)
+            {
+                this.listeners.remove(listener);
+            }
+
+            public void trigger(IRecipe recipe)
+            {
+                List<ICriterionTrigger.Listener<RecipeUnlockedTrigger.Instance>> list = null;
+
+                for (ICriterionTrigger.Listener<RecipeUnlockedTrigger.Instance> listener : this.listeners)
+                {
+                    if (((RecipeUnlockedTrigger.Instance)listener.getCriterionInstance()).test(recipe))
+                    {
+                        if (list == null)
+                        {
+                            list = Lists.<ICriterionTrigger.Listener<RecipeUnlockedTrigger.Instance>>newArrayList();
+                        }
+
+                        list.add(listener);
+                    }
+                }
+
+                if (list != null)
+                {
+                    for (ICriterionTrigger.Listener<RecipeUnlockedTrigger.Instance> listener1 : list)
+                    {
+                        listener1.grantCriterion(this.playerAdvancements);
+                    }
+                }
+            }
+        }
+}

build/tmp/recompileMc/sources/net/minecraft/advancements/critereon/SummonedEntityTrigger.java

@@ -0,0 +1,146 @@
+package net.minecraft.advancements.critereon;
+
+import com.google.common.collect.Lists;
+import com.google.common.collect.Maps;
+import com.google.common.collect.Sets;
+import com.google.gson.JsonDeserializationContext;
+import com.google.gson.JsonObject;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import net.minecraft.advancements.ICriterionTrigger;
+import net.minecraft.advancements.PlayerAdvancements;
+import net.minecraft.entity.Entity;
+import net.minecraft.entity.player.EntityPlayerMP;
+import net.minecraft.util.ResourceLocation;
+
+public class SummonedEntityTrigger implements ICriterionTrigger<SummonedEntityTrigger.Instance>
+{
+    private static final ResourceLocation ID = new ResourceLocation("summoned_entity");
+    private final Map<PlayerAdvancements, SummonedEntityTrigger.Listeners> listeners = Maps.<PlayerAdvancements, SummonedEntityTrigger.Listeners>newHashMap();
+
+    public ResourceLocation getId()
+    {
+        return ID;
+    }
+
+    public void addListener(PlayerAdvancements playerAdvancementsIn, ICriterionTrigger.Listener<SummonedEntityTrigger.Instance> listener)
+    {
+        SummonedEntityTrigger.Listeners summonedentitytrigger$listeners = this.listeners.get(playerAdvancementsIn);
+
+        if (summonedentitytrigger$listeners == null)
+        {
+            summonedentitytrigger$listeners = new SummonedEntityTrigger.Listeners(playerAdvancementsIn);
+            this.listeners.put(playerAdvancementsIn, summonedentitytrigger$listeners);
+        }
+
+        summonedentitytrigger$listeners.add(listener);
+    }
+
+    public void removeListener(PlayerAdvancements playerAdvancementsIn, ICriterionTrigger.Listener<SummonedEntityTrigger.Instance> listener)
+    {
+        SummonedEntityTrigger.Listeners summonedentitytrigger$listeners = this.listeners.get(playerAdvancementsIn);
+
+        if (summonedentitytrigger$listeners != null)
+        {
+            summonedentitytrigger$listeners.remove(listener);
+
+            if (summonedentitytrigger$listeners.isEmpty())
+            {
+                this.listeners.remove(playerAdvancementsIn);
+            }
+        }
+    }
+
+    public void removeAllListeners(PlayerAdvancements playerAdvancementsIn)
+    {
+        this.listeners.remove(playerAdvancementsIn);
+    }
+
+    /**
+     * Deserialize a ICriterionInstance of this trigger from the data in the JSON.
+     */
+    public SummonedEntityTrigger.Instance deserializeInstance(JsonObject json, JsonDeserializationContext context)
+    {
+        EntityPredicate entitypredicate = EntityPredicate.deserialize(json.get("entity"));
+        return new SummonedEntityTrigger.Instance(entitypredicate);
+    }
+
+    public void trigger(EntityPlayerMP player, Entity entity)
+    {
+        SummonedEntityTrigger.Listeners summonedentitytrigger$listeners = this.listeners.get(player.getAdvancements());
+
+        if (summonedentitytrigger$listeners != null)
+        {
+            summonedentitytrigger$listeners.trigger(player, entity);
+        }
+    }
+
+    public static class Instance extends AbstractCriterionInstance
+        {
+            private final EntityPredicate entity;
+
+            public Instance(EntityPredicate entity)
+            {
+                super(SummonedEntityTrigger.ID);
+                this.entity = entity;
+            }
+
+            public boolean test(EntityPlayerMP player, Entity entity)
+            {
+                return this.entity.test(player, entity);
+            }
+        }
+
+    static class Listeners
+        {
+            private final PlayerAdvancements playerAdvancements;
+            private final Set<ICriterionTrigger.Listener<SummonedEntityTrigger.Instance>> listeners = Sets.<ICriterionTrigger.Listener<SummonedEntityTrigger.Instance>>newHashSet();
+
+            public Listeners(PlayerAdvancements playerAdvancementsIn)
+            {
+                this.playerAdvancements = playerAdvancementsIn;
+            }
+
+            public boolean isEmpty()
+            {
+                return this.listeners.isEmpty();
+            }
+
+            public void add(ICriterionTrigger.Listener<SummonedEntityTrigger.Instance> listener)
+            {
+                this.listeners.add(listener);
+            }
+
+            public void remove(ICriterionTrigger.Listener<SummonedEntityTrigger.Instance> listener)
+            {
+                this.listeners.remove(listener);
+            }
+
+            public void trigger(EntityPlayerMP player, Entity entity)
+            {
+                List<ICriterionTrigger.Listener<SummonedEntityTrigger.Instance>> list = null;
+
+                for (ICriterionTrigger.Listener<SummonedEntityTrigger.Instance> listener : this.listeners)
+                {
+                    if (((SummonedEntityTrigger.Instance)listener.getCriterionInstance()).test(player, entity))
+                    {
+                        if (list == null)
+                        {
+                            list = Lists.<ICriterionTrigger.Listener<SummonedEntityTrigger.Instance>>newArrayList();
+                        }
+
+                        list.add(listener);
+                    }
+                }
+
+                if (list != null)
+                {
+                    for (ICriterionTrigger.Listener<SummonedEntityTrigger.Instance> listener1 : list)
+                    {
+                        listener1.grantCriterion(this.playerAdvancements);
+                    }
+                }
+            }
+        }
+}

build/tmp/recompileMc/sources/net/minecraft/advancements/critereon/TameAnimalTrigger.java

@@ -0,0 +1,146 @@
+package net.minecraft.advancements.critereon;
+
+import com.google.common.collect.Lists;
+import com.google.common.collect.Maps;
+import com.google.common.collect.Sets;
+import com.google.gson.JsonDeserializationContext;
+import com.google.gson.JsonObject;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import net.minecraft.advancements.ICriterionTrigger;
+import net.minecraft.advancements.PlayerAdvancements;
+import net.minecraft.entity.passive.EntityAnimal;
+import net.minecraft.entity.player.EntityPlayerMP;
+import net.minecraft.util.ResourceLocation;
+
+public class TameAnimalTrigger implements ICriterionTrigger<TameAnimalTrigger.Instance>
+{
+    private static final ResourceLocation ID = new ResourceLocation("tame_animal");
+    private final Map<PlayerAdvancements, TameAnimalTrigger.Listeners> listeners = Maps.<PlayerAdvancements, TameAnimalTrigger.Listeners>newHashMap();
+
+    public ResourceLocation getId()
+    {
+        return ID;
+    }
+
+    public void addListener(PlayerAdvancements playerAdvancementsIn, ICriterionTrigger.Listener<TameAnimalTrigger.Instance> listener)
+    {
+        TameAnimalTrigger.Listeners tameanimaltrigger$listeners = this.listeners.get(playerAdvancementsIn);
+
+        if (tameanimaltrigger$listeners == null)
+        {
+            tameanimaltrigger$listeners = new TameAnimalTrigger.Listeners(playerAdvancementsIn);
+            this.listeners.put(playerAdvancementsIn, tameanimaltrigger$listeners);
+        }
+
+        tameanimaltrigger$listeners.add(listener);
+    }
+
+    public void removeListener(PlayerAdvancements playerAdvancementsIn, ICriterionTrigger.Listener<TameAnimalTrigger.Instance> listener)
+    {
+        TameAnimalTrigger.Listeners tameanimaltrigger$listeners = this.listeners.get(playerAdvancementsIn);
+
+        if (tameanimaltrigger$listeners != null)
+        {
+            tameanimaltrigger$listeners.remove(listener);
+
+            if (tameanimaltrigger$listeners.isEmpty())
+            {
+                this.listeners.remove(playerAdvancementsIn);
+            }
+        }
+    }
+
+    public void removeAllListeners(PlayerAdvancements playerAdvancementsIn)
+    {
+        this.listeners.remove(playerAdvancementsIn);
+    }
+
+    /**
+     * Deserialize a ICriterionInstance of this trigger from the data in the JSON.
+     */
+    public TameAnimalTrigger.Instance deserializeInstance(JsonObject json, JsonDeserializationContext context)
+    {
+        EntityPredicate entitypredicate = EntityPredicate.deserialize(json.get("entity"));
+        return new TameAnimalTrigger.Instance(entitypredicate);
+    }
+
+    public void trigger(EntityPlayerMP player, EntityAnimal entity)
+    {
+        TameAnimalTrigger.Listeners tameanimaltrigger$listeners = this.listeners.get(player.getAdvancements());
+
+        if (tameanimaltrigger$listeners != null)
+        {
+            tameanimaltrigger$listeners.trigger(player, entity);
+        }
+    }
+
+    public static class Instance extends AbstractCriterionInstance
+        {
+            private final EntityPredicate entity;
+
+            public Instance(EntityPredicate entity)
+            {
+                super(TameAnimalTrigger.ID);
+                this.entity = entity;
+            }
+
+            public boolean test(EntityPlayerMP player, EntityAnimal entity)
+            {
+                return this.entity.test(player, entity);
+            }
+        }
+
+    static class Listeners
+        {
+            private final PlayerAdvancements playerAdvancements;
+            private final Set<ICriterionTrigger.Listener<TameAnimalTrigger.Instance>> listeners = Sets.<ICriterionTrigger.Listener<TameAnimalTrigger.Instance>>newHashSet();
+
+            public Listeners(PlayerAdvancements playerAdvancementsIn)
+            {
+                this.playerAdvancements = playerAdvancementsIn;
+            }
+
+            public boolean isEmpty()
+            {
+                return this.listeners.isEmpty();
+            }
+
+            public void add(ICriterionTrigger.Listener<TameAnimalTrigger.Instance> listener)
+            {
+                this.listeners.add(listener);
+            }
+
+            public void remove(ICriterionTrigger.Listener<TameAnimalTrigger.Instance> listener)
+            {
+                this.listeners.remove(listener);
+            }
+
+            public void trigger(EntityPlayerMP player, EntityAnimal entity)
+            {
+                List<ICriterionTrigger.Listener<TameAnimalTrigger.Instance>> list = null;
+
+                for (ICriterionTrigger.Listener<TameAnimalTrigger.Instance> listener : this.listeners)
+                {
+                    if (((TameAnimalTrigger.Instance)listener.getCriterionInstance()).test(player, entity))
+                    {
+                        if (list == null)
+                        {
+                            list = Lists.<ICriterionTrigger.Listener<TameAnimalTrigger.Instance>>newArrayList();
+                        }
+
+                        list.add(listener);
+                    }
+                }
+
+                if (list != null)
+                {
+                    for (ICriterionTrigger.Listener<TameAnimalTrigger.Instance> listener1 : list)
+                    {
+                        listener1.grantCriterion(this.playerAdvancements);
+                    }
+                }
+            }
+        }
+}

build/tmp/recompileMc/sources/net/minecraft/advancements/critereon/TickTrigger.java

@@ -0,0 +1,117 @@
+package net.minecraft.advancements.critereon;
+
+import com.google.common.collect.Lists;
+import com.google.common.collect.Maps;
+import com.google.common.collect.Sets;
+import com.google.gson.JsonDeserializationContext;
+import com.google.gson.JsonObject;
+import java.util.Map;
+import java.util.Set;
+import net.minecraft.advancements.ICriterionTrigger;
+import net.minecraft.advancements.PlayerAdvancements;
+import net.minecraft.entity.player.EntityPlayerMP;
+import net.minecraft.util.ResourceLocation;
+
+public class TickTrigger implements ICriterionTrigger<TickTrigger.Instance>
+{
+    public static final ResourceLocation ID = new ResourceLocation("tick");
+    private final Map<PlayerAdvancements, TickTrigger.Listeners> listeners = Maps.<PlayerAdvancements, TickTrigger.Listeners>newHashMap();
+
+    public ResourceLocation getId()
+    {
+        return ID;
+    }
+
+    public void addListener(PlayerAdvancements playerAdvancementsIn, ICriterionTrigger.Listener<TickTrigger.Instance> listener)
+    {
+        TickTrigger.Listeners ticktrigger$listeners = this.listeners.get(playerAdvancementsIn);
+
+        if (ticktrigger$listeners == null)
+        {
+            ticktrigger$listeners = new TickTrigger.Listeners(playerAdvancementsIn);
+            this.listeners.put(playerAdvancementsIn, ticktrigger$listeners);
+        }
+
+        ticktrigger$listeners.add(listener);
+    }
+
+    public void removeListener(PlayerAdvancements playerAdvancementsIn, ICriterionTrigger.Listener<TickTrigger.Instance> listener)
+    {
+        TickTrigger.Listeners ticktrigger$listeners = this.listeners.get(playerAdvancementsIn);
+
+        if (ticktrigger$listeners != null)
+        {
+            ticktrigger$listeners.remove(listener);
+
+            if (ticktrigger$listeners.isEmpty())
+            {
+                this.listeners.remove(playerAdvancementsIn);
+            }
+        }
+    }
+
+    public void removeAllListeners(PlayerAdvancements playerAdvancementsIn)
+    {
+        this.listeners.remove(playerAdvancementsIn);
+    }
+
+    /**
+     * Deserialize a ICriterionInstance of this trigger from the data in the JSON.
+     */
+    public TickTrigger.Instance deserializeInstance(JsonObject json, JsonDeserializationContext context)
+    {
+        return new TickTrigger.Instance();
+    }
+
+    public void trigger(EntityPlayerMP player)
+    {
+        TickTrigger.Listeners ticktrigger$listeners = this.listeners.get(player.getAdvancements());
+
+        if (ticktrigger$listeners != null)
+        {
+            ticktrigger$listeners.trigger();
+        }
+    }
+
+    public static class Instance extends AbstractCriterionInstance
+        {
+            public Instance()
+            {
+                super(TickTrigger.ID);
+            }
+        }
+
+    static class Listeners
+        {
+            private final PlayerAdvancements playerAdvancements;
+            private final Set<ICriterionTrigger.Listener<TickTrigger.Instance>> listeners = Sets.<ICriterionTrigger.Listener<TickTrigger.Instance>>newHashSet();
+
+            public Listeners(PlayerAdvancements playerAdvancementsIn)
+            {
+                this.playerAdvancements = playerAdvancementsIn;
+            }
+
+            public boolean isEmpty()
+            {
+                return this.listeners.isEmpty();
+            }
+
+            public void add(ICriterionTrigger.Listener<TickTrigger.Instance> listener)
+            {
+                this.listeners.add(listener);
+            }
+
+            public void remove(ICriterionTrigger.Listener<TickTrigger.Instance> listener)
+            {
+                this.listeners.remove(listener);
+            }
+
+            public void trigger()
+            {
+                for (ICriterionTrigger.Listener<TickTrigger.Instance> listener : Lists.newArrayList(this.listeners))
+                {
+                    listener.grantCriterion(this.playerAdvancements);
+                }
+            }
+        }
+}

build/tmp/recompileMc/sources/net/minecraft/advancements/critereon/UsedEnderEyeTrigger.java

@@ -0,0 +1,148 @@
+package net.minecraft.advancements.critereon;
+
+import com.google.common.collect.Lists;
+import com.google.common.collect.Maps;
+import com.google.common.collect.Sets;
+import com.google.gson.JsonDeserializationContext;
+import com.google.gson.JsonObject;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import net.minecraft.advancements.ICriterionTrigger;
+import net.minecraft.advancements.PlayerAdvancements;
+import net.minecraft.entity.player.EntityPlayerMP;
+import net.minecraft.util.ResourceLocation;
+import net.minecraft.util.math.BlockPos;
+
+public class UsedEnderEyeTrigger implements ICriterionTrigger<UsedEnderEyeTrigger.Instance>
+{
+    private static final ResourceLocation ID = new ResourceLocation("used_ender_eye");
+    private final Map<PlayerAdvancements, UsedEnderEyeTrigger.Listeners> listeners = Maps.<PlayerAdvancements, UsedEnderEyeTrigger.Listeners>newHashMap();
+
+    public ResourceLocation getId()
+    {
+        return ID;
+    }
+
+    public void addListener(PlayerAdvancements playerAdvancementsIn, ICriterionTrigger.Listener<UsedEnderEyeTrigger.Instance> listener)
+    {
+        UsedEnderEyeTrigger.Listeners usedendereyetrigger$listeners = this.listeners.get(playerAdvancementsIn);
+
+        if (usedendereyetrigger$listeners == null)
+        {
+            usedendereyetrigger$listeners = new UsedEnderEyeTrigger.Listeners(playerAdvancementsIn);
+            this.listeners.put(playerAdvancementsIn, usedendereyetrigger$listeners);
+        }
+
+        usedendereyetrigger$listeners.add(listener);
+    }
+
+    public void removeListener(PlayerAdvancements playerAdvancementsIn, ICriterionTrigger.Listener<UsedEnderEyeTrigger.Instance> listener)
+    {
+        UsedEnderEyeTrigger.Listeners usedendereyetrigger$listeners = this.listeners.get(playerAdvancementsIn);
+
+        if (usedendereyetrigger$listeners != null)
+        {
+            usedendereyetrigger$listeners.remove(listener);
+
+            if (usedendereyetrigger$listeners.isEmpty())
+            {
+                this.listeners.remove(playerAdvancementsIn);
+            }
+        }
+    }
+
+    public void removeAllListeners(PlayerAdvancements playerAdvancementsIn)
+    {
+        this.listeners.remove(playerAdvancementsIn);
+    }
+
+    /**
+     * Deserialize a ICriterionInstance of this trigger from the data in the JSON.
+     */
+    public UsedEnderEyeTrigger.Instance deserializeInstance(JsonObject json, JsonDeserializationContext context)
+    {
+        MinMaxBounds minmaxbounds = MinMaxBounds.deserialize(json.get("distance"));
+        return new UsedEnderEyeTrigger.Instance(minmaxbounds);
+    }
+
+    public void trigger(EntityPlayerMP player, BlockPos pos)
+    {
+        UsedEnderEyeTrigger.Listeners usedendereyetrigger$listeners = this.listeners.get(player.getAdvancements());
+
+        if (usedendereyetrigger$listeners != null)
+        {
+            double d0 = player.posX - (double)pos.getX();
+            double d1 = player.posZ - (double)pos.getZ();
+            usedendereyetrigger$listeners.trigger(d0 * d0 + d1 * d1);
+        }
+    }
+
+    public static class Instance extends AbstractCriterionInstance
+        {
+            private final MinMaxBounds distance;
+
+            public Instance(MinMaxBounds distance)
+            {
+                super(UsedEnderEyeTrigger.ID);
+                this.distance = distance;
+            }
+
+            public boolean test(double distanceSq)
+            {
+                return this.distance.testSquare(distanceSq);
+            }
+        }
+
+    static class Listeners
+        {
+            private final PlayerAdvancements playerAdvancements;
+            private final Set<ICriterionTrigger.Listener<UsedEnderEyeTrigger.Instance>> listeners = Sets.<ICriterionTrigger.Listener<UsedEnderEyeTrigger.Instance>>newHashSet();
+
+            public Listeners(PlayerAdvancements playerAdvancementsIn)
+            {
+                this.playerAdvancements = playerAdvancementsIn;
+            }
+
+            public boolean isEmpty()
+            {
+                return this.listeners.isEmpty();
+            }
+
+            public void add(ICriterionTrigger.Listener<UsedEnderEyeTrigger.Instance> listener)
+            {
+                this.listeners.add(listener);
+            }
+
+            public void remove(ICriterionTrigger.Listener<UsedEnderEyeTrigger.Instance> listener)
+            {
+                this.listeners.remove(listener);
+            }
+
+            public void trigger(double distanceSq)
+            {
+                List<ICriterionTrigger.Listener<UsedEnderEyeTrigger.Instance>> list = null;
+
+                for (ICriterionTrigger.Listener<UsedEnderEyeTrigger.Instance> listener : this.listeners)
+                {
+                    if (((UsedEnderEyeTrigger.Instance)listener.getCriterionInstance()).test(distanceSq))
+                    {
+                        if (list == null)
+                        {
+                            list = Lists.<ICriterionTrigger.Listener<UsedEnderEyeTrigger.Instance>>newArrayList();
+                        }
+
+                        list.add(listener);
+                    }
+                }
+
+                if (list != null)
+                {
+                    for (ICriterionTrigger.Listener<UsedEnderEyeTrigger.Instance> listener1 : list)
+                    {
+                        listener1.grantCriterion(this.playerAdvancements);
+                    }
+                }
+            }
+        }
+}

build/tmp/recompileMc/sources/net/minecraft/advancements/critereon/UsedTotemTrigger.java

@@ -0,0 +1,146 @@
+package net.minecraft.advancements.critereon;
+
+import com.google.common.collect.Lists;
+import com.google.common.collect.Maps;
+import com.google.common.collect.Sets;
+import com.google.gson.JsonDeserializationContext;
+import com.google.gson.JsonObject;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import net.minecraft.advancements.ICriterionTrigger;
+import net.minecraft.advancements.PlayerAdvancements;
+import net.minecraft.entity.player.EntityPlayerMP;
+import net.minecraft.item.ItemStack;
+import net.minecraft.util.ResourceLocation;
+
+public class UsedTotemTrigger implements ICriterionTrigger<UsedTotemTrigger.Instance>
+{
+    private static final ResourceLocation ID = new ResourceLocation("used_totem");
+    private final Map<PlayerAdvancements, UsedTotemTrigger.Listeners> listeners = Maps.<PlayerAdvancements, UsedTotemTrigger.Listeners>newHashMap();
+
+    public ResourceLocation getId()
+    {
+        return ID;
+    }
+
+    public void addListener(PlayerAdvancements playerAdvancementsIn, ICriterionTrigger.Listener<UsedTotemTrigger.Instance> listener)
+    {
+        UsedTotemTrigger.Listeners usedtotemtrigger$listeners = this.listeners.get(playerAdvancementsIn);
+
+        if (usedtotemtrigger$listeners == null)
+        {
+            usedtotemtrigger$listeners = new UsedTotemTrigger.Listeners(playerAdvancementsIn);
+            this.listeners.put(playerAdvancementsIn, usedtotemtrigger$listeners);
+        }
+
+        usedtotemtrigger$listeners.add(listener);
+    }
+
+    public void removeListener(PlayerAdvancements playerAdvancementsIn, ICriterionTrigger.Listener<UsedTotemTrigger.Instance> listener)
+    {
+        UsedTotemTrigger.Listeners usedtotemtrigger$listeners = this.listeners.get(playerAdvancementsIn);
+
+        if (usedtotemtrigger$listeners != null)
+        {
+            usedtotemtrigger$listeners.remove(listener);
+
+            if (usedtotemtrigger$listeners.isEmpty())
+            {
+                this.listeners.remove(playerAdvancementsIn);
+            }
+        }
+    }
+
+    public void removeAllListeners(PlayerAdvancements playerAdvancementsIn)
+    {
+        this.listeners.remove(playerAdvancementsIn);
+    }
+
+    /**
+     * Deserialize a ICriterionInstance of this trigger from the data in the JSON.
+     */
+    public UsedTotemTrigger.Instance deserializeInstance(JsonObject json, JsonDeserializationContext context)
+    {
+        ItemPredicate itempredicate = ItemPredicate.deserialize(json.get("item"));
+        return new UsedTotemTrigger.Instance(itempredicate);
+    }
+
+    public void trigger(EntityPlayerMP player, ItemStack item)
+    {
+        UsedTotemTrigger.Listeners usedtotemtrigger$listeners = this.listeners.get(player.getAdvancements());
+
+        if (usedtotemtrigger$listeners != null)
+        {
+            usedtotemtrigger$listeners.trigger(item);
+        }
+    }
+
+    public static class Instance extends AbstractCriterionInstance
+        {
+            private final ItemPredicate item;
+
+            public Instance(ItemPredicate item)
+            {
+                super(UsedTotemTrigger.ID);
+                this.item = item;
+            }
+
+            public boolean test(ItemStack item)
+            {
+                return this.item.test(item);
+            }
+        }
+
+    static class Listeners
+        {
+            private final PlayerAdvancements playerAdvancements;
+            private final Set<ICriterionTrigger.Listener<UsedTotemTrigger.Instance>> listeners = Sets.<ICriterionTrigger.Listener<UsedTotemTrigger.Instance>>newHashSet();
+
+            public Listeners(PlayerAdvancements playerAdvancementsIn)
+            {
+                this.playerAdvancements = playerAdvancementsIn;
+            }
+
+            public boolean isEmpty()
+            {
+                return this.listeners.isEmpty();
+            }
+
+            public void add(ICriterionTrigger.Listener<UsedTotemTrigger.Instance> listener)
+            {
+                this.listeners.add(listener);
+            }
+
+            public void remove(ICriterionTrigger.Listener<UsedTotemTrigger.Instance> listener)
+            {
+                this.listeners.remove(listener);
+            }
+
+            public void trigger(ItemStack item)
+            {
+                List<ICriterionTrigger.Listener<UsedTotemTrigger.Instance>> list = null;
+
+                for (ICriterionTrigger.Listener<UsedTotemTrigger.Instance> listener : this.listeners)
+                {
+                    if (((UsedTotemTrigger.Instance)listener.getCriterionInstance()).test(item))
+                    {
+                        if (list == null)
+                        {
+                            list = Lists.<ICriterionTrigger.Listener<UsedTotemTrigger.Instance>>newArrayList();
+                        }
+
+                        list.add(listener);
+                    }
+                }
+
+                if (list != null)
+                {
+                    for (ICriterionTrigger.Listener<UsedTotemTrigger.Instance> listener1 : list)
+                    {
+                        listener1.grantCriterion(this.playerAdvancements);
+                    }
+                }
+            }
+        }
+}

build/tmp/recompileMc/sources/net/minecraft/advancements/critereon/VillagerTradeTrigger.java

@@ -0,0 +1,157 @@
+package net.minecraft.advancements.critereon;
+
+import com.google.common.collect.Lists;
+import com.google.common.collect.Maps;
+import com.google.common.collect.Sets;
+import com.google.gson.JsonDeserializationContext;
+import com.google.gson.JsonObject;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import net.minecraft.advancements.ICriterionTrigger;
+import net.minecraft.advancements.PlayerAdvancements;
+import net.minecraft.entity.passive.EntityVillager;
+import net.minecraft.entity.player.EntityPlayerMP;
+import net.minecraft.item.ItemStack;
+import net.minecraft.util.ResourceLocation;
+
+public class VillagerTradeTrigger implements ICriterionTrigger<VillagerTradeTrigger.Instance>
+{
+    private static final ResourceLocation ID = new ResourceLocation("villager_trade");
+    private final Map<PlayerAdvancements, VillagerTradeTrigger.Listeners> listeners = Maps.<PlayerAdvancements, VillagerTradeTrigger.Listeners>newHashMap();
+
+    public ResourceLocation getId()
+    {
+        return ID;
+    }
+
+    public void addListener(PlayerAdvancements playerAdvancementsIn, ICriterionTrigger.Listener<VillagerTradeTrigger.Instance> listener)
+    {
+        VillagerTradeTrigger.Listeners villagertradetrigger$listeners = this.listeners.get(playerAdvancementsIn);
+
+        if (villagertradetrigger$listeners == null)
+        {
+            villagertradetrigger$listeners = new VillagerTradeTrigger.Listeners(playerAdvancementsIn);
+            this.listeners.put(playerAdvancementsIn, villagertradetrigger$listeners);
+        }
+
+        villagertradetrigger$listeners.add(listener);
+    }
+
+    public void removeListener(PlayerAdvancements playerAdvancementsIn, ICriterionTrigger.Listener<VillagerTradeTrigger.Instance> listener)
+    {
+        VillagerTradeTrigger.Listeners villagertradetrigger$listeners = this.listeners.get(playerAdvancementsIn);
+
+        if (villagertradetrigger$listeners != null)
+        {
+            villagertradetrigger$listeners.remove(listener);
+
+            if (villagertradetrigger$listeners.isEmpty())
+            {
+                this.listeners.remove(playerAdvancementsIn);
+            }
+        }
+    }
+
+    public void removeAllListeners(PlayerAdvancements playerAdvancementsIn)
+    {
+        this.listeners.remove(playerAdvancementsIn);
+    }
+
+    /**
+     * Deserialize a ICriterionInstance of this trigger from the data in the JSON.
+     */
+    public VillagerTradeTrigger.Instance deserializeInstance(JsonObject json, JsonDeserializationContext context)
+    {
+        EntityPredicate entitypredicate = EntityPredicate.deserialize(json.get("villager"));
+        ItemPredicate itempredicate = ItemPredicate.deserialize(json.get("item"));
+        return new VillagerTradeTrigger.Instance(entitypredicate, itempredicate);
+    }
+
+    public void trigger(EntityPlayerMP player, EntityVillager villager, ItemStack item)
+    {
+        VillagerTradeTrigger.Listeners villagertradetrigger$listeners = this.listeners.get(player.getAdvancements());
+
+        if (villagertradetrigger$listeners != null)
+        {
+            villagertradetrigger$listeners.trigger(player, villager, item);
+        }
+    }
+
+    public static class Instance extends AbstractCriterionInstance
+        {
+            private final EntityPredicate villager;
+            private final ItemPredicate item;
+
+            public Instance(EntityPredicate villager, ItemPredicate item)
+            {
+                super(VillagerTradeTrigger.ID);
+                this.villager = villager;
+                this.item = item;
+            }
+
+            public boolean test(EntityPlayerMP player, EntityVillager villager, ItemStack item)
+            {
+                if (!this.villager.test(player, villager))
+                {
+                    return false;
+                }
+                else
+                {
+                    return this.item.test(item);
+                }
+            }
+        }
+
+    static class Listeners
+        {
+            private final PlayerAdvancements playerAdvancements;
+            private final Set<ICriterionTrigger.Listener<VillagerTradeTrigger.Instance>> listeners = Sets.<ICriterionTrigger.Listener<VillagerTradeTrigger.Instance>>newHashSet();
+
+            public Listeners(PlayerAdvancements playerAdvancementsIn)
+            {
+                this.playerAdvancements = playerAdvancementsIn;
+            }
+
+            public boolean isEmpty()
+            {
+                return this.listeners.isEmpty();
+            }
+
+            public void add(ICriterionTrigger.Listener<VillagerTradeTrigger.Instance> listener)
+            {
+                this.listeners.add(listener);
+            }
+
+            public void remove(ICriterionTrigger.Listener<VillagerTradeTrigger.Instance> listener)
+            {
+                this.listeners.remove(listener);
+            }
+
+            public void trigger(EntityPlayerMP player, EntityVillager villager, ItemStack item)
+            {
+                List<ICriterionTrigger.Listener<VillagerTradeTrigger.Instance>> list = null;
+
+                for (ICriterionTrigger.Listener<VillagerTradeTrigger.Instance> listener : this.listeners)
+                {
+                    if (((VillagerTradeTrigger.Instance)listener.getCriterionInstance()).test(player, villager, item))
+                    {
+                        if (list == null)
+                        {
+                            list = Lists.<ICriterionTrigger.Listener<VillagerTradeTrigger.Instance>>newArrayList();
+                        }
+
+                        list.add(listener);
+                    }
+                }
+
+                if (list != null)
+                {
+                    for (ICriterionTrigger.Listener<VillagerTradeTrigger.Instance> listener1 : list)
+                    {
+                        listener1.grantCriterion(this.playerAdvancements);
+                    }
+                }
+            }
+        }
+}

build/tmp/recompileMc/sources/net/minecraft/advancements/critereon/package-info.java

@@ -0,0 +1,7 @@
+// Auto generated package-info by MCP
+@ParametersAreNonnullByDefault
+@MethodsReturnNonnullByDefault
+package net.minecraft.advancements.critereon;
+
+import mcp.MethodsReturnNonnullByDefault;
+import javax.annotation.ParametersAreNonnullByDefault;

build/tmp/recompileMc/sources/net/minecraft/advancements/package-info.java

@@ -0,0 +1,7 @@
+// Auto generated package-info by MCP
+@ParametersAreNonnullByDefault
+@MethodsReturnNonnullByDefault
+package net.minecraft.advancements;
+
+import mcp.MethodsReturnNonnullByDefault;
+import javax.annotation.ParametersAreNonnullByDefault;