base mod created

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;