diff --git a/MineTweaker3-API/src/main/java/minetweaker/MineTweakerAPI.java b/MineTweaker3-API/src/main/java/minetweaker/MineTweakerAPI.java index 6495629..5b79455 100644 --- a/MineTweaker3-API/src/main/java/minetweaker/MineTweakerAPI.java +++ b/MineTweaker3-API/src/main/java/minetweaker/MineTweakerAPI.java @@ -6,6 +6,7 @@ import java.lang.reflect.InvocationTargetException; import java.lang.reflect.Method; import java.lang.reflect.Modifier; import java.util.ArrayList; +import java.util.Arrays; import java.util.List; import java.util.logging.Level; import java.util.logging.Logger; @@ -265,14 +266,18 @@ public class MineTweakerAPI { for (Annotation annotation : cls.getAnnotations()) { if (annotation instanceof ModOnly) { String[] value = ((ModOnly) annotation).value(); + String version = ((ModOnly) annotation).version(); + for (String mod : value) { - if (!loadedMods.contains(mod)) { - continue outer; // skip this class - } + if (!loadedMods.contains(mod)) + continue outer; + + if (!loadedMods.get(mod).getVersion().startsWith(version)) + continue outer; } } } - + MineTweakerAPI.registerClass(cls); } diff --git a/MineTweaker3-API/src/main/java/minetweaker/annotations/ModOnly.java b/MineTweaker3-API/src/main/java/minetweaker/annotations/ModOnly.java index 1d6300e..8d49b19 100644 --- a/MineTweaker3-API/src/main/java/minetweaker/annotations/ModOnly.java +++ b/MineTweaker3-API/src/main/java/minetweaker/annotations/ModOnly.java @@ -15,4 +15,5 @@ import java.lang.annotation.Target; @Target({ElementType.TYPE, ElementType.METHOD}) public @interface ModOnly { public String[] value(); + public String version() default ""; } diff --git a/MineTweaker3-API/src/main/java/minetweaker/api/item/IIngredient.java b/MineTweaker3-API/src/main/java/minetweaker/api/item/IIngredient.java index dc1ae48..7a7430c 100644 --- a/MineTweaker3-API/src/main/java/minetweaker/api/item/IIngredient.java +++ b/MineTweaker3-API/src/main/java/minetweaker/api/item/IIngredient.java @@ -1,6 +1,7 @@ package minetweaker.api.item; import java.util.List; +import minetweaker.api.liquid.ILiquidStack; import minetweaker.api.player.IPlayer; import stanhebben.zenscript.annotations.OperatorType; import stanhebben.zenscript.annotations.ZenClass; @@ -51,6 +52,17 @@ public interface IIngredient { @ZenGetter("items") public List getItems(); + /** + * Gets all possible liquids for this ingredient. + * + * If there is no liquid list (for example, it is the <*&ft; wildcard item) + * null should be returned. + * + * @return the liquids for this ingredient, or null + */ + @ZenGetter("liquids") + public List getLiquids(); + /** * Returns a new ingredient with the given stack size. * @@ -100,7 +112,8 @@ public interface IIngredient { public IIngredient marked(String mark); /** - * Checks if this ingredient matches the given item. + * Checks if this ingredient matches the given item. For liquids, will + * match the item if it is a valid container. * * @param item item to check * @return true if the item matches @@ -108,6 +121,15 @@ public interface IIngredient { @ZenMethod public boolean matches(IItemStack item); + /** + * Checks if this ingredient matches the given liquid. + * + * @param liquid + * @return + */ + @ZenMethod + public boolean matches(ILiquidStack liquid); + /** * Check if this ingredient contains all possible values for the given * ingredient. diff --git a/MineTweaker3-API/src/main/java/minetweaker/api/item/IngredientAny.java b/MineTweaker3-API/src/main/java/minetweaker/api/item/IngredientAny.java index eade319..69b500e 100644 --- a/MineTweaker3-API/src/main/java/minetweaker/api/item/IngredientAny.java +++ b/MineTweaker3-API/src/main/java/minetweaker/api/item/IngredientAny.java @@ -1,6 +1,7 @@ package minetweaker.api.item; import java.util.List; +import minetweaker.api.liquid.ILiquidStack; import minetweaker.api.player.IPlayer; import minetweaker.util.ArrayUtil; @@ -30,6 +31,11 @@ public class IngredientAny implements IIngredient { public List getItems() { return null; } + + @Override + public List getLiquids() { + return null; + } @Override public IIngredient amount(int amount) { @@ -60,6 +66,11 @@ public class IngredientAny implements IIngredient { public boolean matches(IItemStack item) { return true; } + + @Override + public boolean matches(ILiquidStack liquid) { + return true; + } @Override public boolean contains(IIngredient ingredient) { diff --git a/MineTweaker3-API/src/main/java/minetweaker/api/item/IngredientAnyAdvanced.java b/MineTweaker3-API/src/main/java/minetweaker/api/item/IngredientAnyAdvanced.java index 658e1be..7790c7d 100644 --- a/MineTweaker3-API/src/main/java/minetweaker/api/item/IngredientAnyAdvanced.java +++ b/MineTweaker3-API/src/main/java/minetweaker/api/item/IngredientAnyAdvanced.java @@ -1,6 +1,7 @@ package minetweaker.api.item; import java.util.List; +import minetweaker.api.liquid.ILiquidStack; import minetweaker.api.player.IPlayer; import minetweaker.util.ArrayUtil; @@ -35,6 +36,11 @@ public class IngredientAnyAdvanced implements IIngredient { public List getItems() { return null; } + + @Override + public List getLiquids() { + return null; + } @Override public IIngredient amount(int amount) { @@ -63,6 +69,7 @@ public class IngredientAnyAdvanced implements IIngredient { @Override public boolean matches(IItemStack item) { + // TODO: what is the point of this? if (!item.matches(item)) return false; for (IItemCondition condition : conditions) { @@ -71,6 +78,12 @@ public class IngredientAnyAdvanced implements IIngredient { return true; } + + @Override + public boolean matches(ILiquidStack liquid) { + // TODO: conditions on liquids? + return true; + } @Override public boolean contains(IIngredient ingredient) { diff --git a/MineTweaker3-API/src/main/java/minetweaker/api/item/IngredientItem.java b/MineTweaker3-API/src/main/java/minetweaker/api/item/IngredientItem.java index d6ff1a7..e273c69 100644 --- a/MineTweaker3-API/src/main/java/minetweaker/api/item/IngredientItem.java +++ b/MineTweaker3-API/src/main/java/minetweaker/api/item/IngredientItem.java @@ -2,6 +2,7 @@ package minetweaker.api.item; import java.util.Collections; import java.util.List; +import minetweaker.api.liquid.ILiquidStack; import minetweaker.api.player.IPlayer; import minetweaker.util.ArrayUtil; @@ -40,6 +41,11 @@ public class IngredientItem implements IIngredient { public List getItems() { return items; } + + @Override + public List getLiquids() { + return Collections.emptyList(); + } @Override public IIngredient amount(int amount) { @@ -76,6 +82,11 @@ public class IngredientItem implements IIngredient { return true; } + + @Override + public boolean matches(ILiquidStack liquid) { + return false; + } @Override public boolean contains(IIngredient ingredient) { diff --git a/MineTweaker3-API/src/main/java/minetweaker/api/item/IngredientOr.java b/MineTweaker3-API/src/main/java/minetweaker/api/item/IngredientOr.java index 4508f83..fc06a90 100644 --- a/MineTweaker3-API/src/main/java/minetweaker/api/item/IngredientOr.java +++ b/MineTweaker3-API/src/main/java/minetweaker/api/item/IngredientOr.java @@ -8,6 +8,7 @@ package minetweaker.api.item; import java.util.ArrayList; import java.util.List; +import minetweaker.api.liquid.ILiquidStack; import minetweaker.api.player.IPlayer; import minetweaker.util.ArrayUtil; @@ -57,6 +58,15 @@ public class IngredientOr implements IIngredient { } return result; } + + @Override + public List getLiquids() { + List result = new ArrayList(); + for (IIngredient element : elements) { + result.addAll(element.getLiquids()); + } + return result; + } @Override public IIngredient amount(int amount) { @@ -89,13 +99,23 @@ public class IngredientOr implements IIngredient { @Override public boolean matches(IItemStack item) { - for (IIngredient ingredient : item.getItems()) { + for (IIngredient ingredient : elements) { if (ingredient.matches(item)) return true; } return false; } + + @Override + public boolean matches(ILiquidStack liquid) { + for (IIngredient ingredient : elements) { + if (ingredient.matches(liquid)) + return true; + } + + return false; + } @Override public boolean contains(IIngredient ingredient) { diff --git a/MineTweaker3-API/src/main/java/minetweaker/api/item/IngredientStack.java b/MineTweaker3-API/src/main/java/minetweaker/api/item/IngredientStack.java index 89296fe..d7ccc70 100644 --- a/MineTweaker3-API/src/main/java/minetweaker/api/item/IngredientStack.java +++ b/MineTweaker3-API/src/main/java/minetweaker/api/item/IngredientStack.java @@ -1,6 +1,8 @@ package minetweaker.api.item; +import java.util.Collections; import java.util.List; +import minetweaker.api.liquid.ILiquidStack; import minetweaker.api.player.IPlayer; /** @@ -32,6 +34,11 @@ public class IngredientStack implements IIngredient { public List getItems() { return ingredient.getItems(); } + + @Override + public List getLiquids() { + return Collections.emptyList(); + } @Override public IIngredient amount(int amount) { @@ -62,6 +69,11 @@ public class IngredientStack implements IIngredient { public boolean matches(IItemStack item) { return item.getAmount() == amount && ingredient.matches(item); } + + @Override + public boolean matches(ILiquidStack liquid) { + return false; + } @Override public boolean contains(IIngredient ingredient) { diff --git a/MineTweaker3-API/src/main/java/minetweaker/api/item/IngredientUnknown.java b/MineTweaker3-API/src/main/java/minetweaker/api/item/IngredientUnknown.java index 701c0c9..539cdcd 100644 --- a/MineTweaker3-API/src/main/java/minetweaker/api/item/IngredientUnknown.java +++ b/MineTweaker3-API/src/main/java/minetweaker/api/item/IngredientUnknown.java @@ -8,6 +8,7 @@ package minetweaker.api.item; import java.util.Collections; import java.util.List; +import minetweaker.api.liquid.ILiquidStack; import minetweaker.api.player.IPlayer; /** @@ -42,6 +43,12 @@ public class IngredientUnknown implements IIngredient { return Collections.emptyList(); } + + @Override + public List getLiquids() + { + return Collections.emptyList(); + } @Override public IIngredient amount(int amount) @@ -78,6 +85,12 @@ public class IngredientUnknown implements IIngredient { return false; } + + @Override + public boolean matches(ILiquidStack liquid) + { + return false; + } @Override public boolean contains(IIngredient ingredient) diff --git a/MineTweaker3-API/src/main/java/minetweaker/api/liquid/ILiquidStack.java b/MineTweaker3-API/src/main/java/minetweaker/api/liquid/ILiquidStack.java index 2df1a69..bf003ff 100644 --- a/MineTweaker3-API/src/main/java/minetweaker/api/liquid/ILiquidStack.java +++ b/MineTweaker3-API/src/main/java/minetweaker/api/liquid/ILiquidStack.java @@ -7,6 +7,7 @@ package minetweaker.api.liquid; import minetweaker.api.data.IData; +import minetweaker.api.item.IIngredient; import stanhebben.zenscript.annotations.OperatorType; import stanhebben.zenscript.annotations.ZenClass; import stanhebben.zenscript.annotations.ZenGetter; @@ -18,7 +19,7 @@ import stanhebben.zenscript.annotations.ZenOperator; * @author Stanneke */ @ZenClass("minetweaker.liquid.ILiquidStack") -public interface ILiquidStack { +public interface ILiquidStack extends IIngredient { @ZenGetter("definition") public ILiquidDefinition getDefinition(); diff --git a/MineTweaker3-API/src/main/java/minetweaker/api/oredict/IngredientOreDict.java b/MineTweaker3-API/src/main/java/minetweaker/api/oredict/IngredientOreDict.java index ffc22c1..04dea14 100644 --- a/MineTweaker3-API/src/main/java/minetweaker/api/oredict/IngredientOreDict.java +++ b/MineTweaker3-API/src/main/java/minetweaker/api/oredict/IngredientOreDict.java @@ -6,6 +6,7 @@ package minetweaker.api.oredict; +import java.util.Collections; import java.util.List; import minetweaker.api.item.IIngredient; import minetweaker.api.item.IItemCondition; @@ -13,6 +14,7 @@ import minetweaker.api.item.IItemStack; import minetweaker.api.item.IItemTransformer; import minetweaker.api.item.IngredientOr; import minetweaker.api.item.IngredientStack; +import minetweaker.api.liquid.ILiquidStack; import minetweaker.api.player.IPlayer; import minetweaker.util.ArrayUtil; @@ -51,6 +53,11 @@ public class IngredientOreDict implements IIngredient { public List getItems() { return entry.getItems(); } + + @Override + public List getLiquids() { + return Collections.emptyList(); + } @Override public IIngredient amount(int amount) { @@ -87,6 +94,11 @@ public class IngredientOreDict implements IIngredient { return true; } + + @Override + public boolean matches(ILiquidStack liquid) { + return false; + } @Override public boolean contains(IIngredient ingredient) { diff --git a/MineTweaker3-MC164-Main/src/main/java/minetweaker/mc164/item/MCItemStack.java b/MineTweaker3-MC164-Main/src/main/java/minetweaker/mc164/item/MCItemStack.java index aa070b9..3abf5b3 100644 --- a/MineTweaker3-MC164-Main/src/main/java/minetweaker/mc164/item/MCItemStack.java +++ b/MineTweaker3-MC164-Main/src/main/java/minetweaker/mc164/item/MCItemStack.java @@ -200,6 +200,11 @@ public class MCItemStack implements IItemStack { public List getItems() { return items; } + + @Override + public List getLiquids() { + return Collections.emptyList(); + } @Override public IItemStack amount(int amount) { @@ -252,6 +257,11 @@ public class MCItemStack implements IItemStack { || stack.getItemDamage() == internal.getItemDamage() || (!stack.getHasSubtypes() && !stack.getItem().isDamageable())); } + + @Override + public boolean matches(ILiquidStack liquid) { + return false; + } @Override public boolean contains(IIngredient ingredient) { diff --git a/MineTweaker3-MC164-Main/src/main/java/minetweaker/mc164/liquid/MCLiquidStack.java b/MineTweaker3-MC164-Main/src/main/java/minetweaker/mc164/liquid/MCLiquidStack.java index b95e331..bbff5f3 100644 --- a/MineTweaker3-MC164-Main/src/main/java/minetweaker/mc164/liquid/MCLiquidStack.java +++ b/MineTweaker3-MC164-Main/src/main/java/minetweaker/mc164/liquid/MCLiquidStack.java @@ -6,10 +6,18 @@ package minetweaker.mc164.liquid; +import java.util.Collections; +import java.util.List; import minetweaker.mc164.data.NBTConverter; import minetweaker.api.data.IData; +import minetweaker.api.item.IIngredient; +import minetweaker.api.item.IItemCondition; +import minetweaker.api.item.IItemStack; +import minetweaker.api.item.IItemTransformer; +import minetweaker.api.item.IngredientOr; import minetweaker.api.liquid.ILiquidDefinition; import minetweaker.api.liquid.ILiquidStack; +import minetweaker.api.player.IPlayer; import net.minecraft.nbt.NBTTagCompound; import net.minecraftforge.fluids.FluidStack; @@ -106,4 +114,96 @@ public class MCLiquidStack implements ILiquidStack { public Object getInternal() { return stack; } + + // ################################## + // ### IIngredient implementation ### + // ################################## + + @Override + public String getMark() + { + return null; + } + + @Override + public List getItems() + { + return Collections.emptyList(); + } + + @Override + public List getLiquids() + { + return Collections.singletonList(this); + } + + @Override + public IIngredient amount(int amount) + { + return withAmount(amount); + } + + @Override + public IIngredient or(IIngredient ingredient) + { + return new IngredientOr(this, ingredient); + } + + @Override + public IIngredient transform(IItemTransformer transformer) + { + throw new UnsupportedOperationException("Liquid stack can't have transformers"); + } + + @Override + public IIngredient only(IItemCondition condition) + { + throw new UnsupportedOperationException("Liquid stack can't have conditions"); + } + + @Override + public IIngredient marked(String mark) + { + throw new UnsupportedOperationException("Liquid stack can't be marked"); + } + + @Override + public boolean matches(IItemStack item) + { + return false; + } + + @Override + public boolean matches(ILiquidStack liquid) + { + return getDefinition().equals(liquid.getDefinition()) + && getAmount() <= liquid.getAmount(); + } + + @Override + public boolean contains(IIngredient ingredient) + { + if (!ingredient.getItems().isEmpty()) + return false; + + for (ILiquidStack liquid : ingredient.getLiquids()) + { + if (!matches(liquid)) + return false; + } + + return false; + } + + @Override + public IItemStack applyTransform(IItemStack item, IPlayer byPlayer) + { + return item; + } + + @Override + public boolean hasTransformers() + { + return false; + } } diff --git a/MineTweaker3-MC164-Main/src/main/java/minetweaker/mc164/oredict/MCOreDictEntry.java b/MineTweaker3-MC164-Main/src/main/java/minetweaker/mc164/oredict/MCOreDictEntry.java index be86529..e802803 100644 --- a/MineTweaker3-MC164-Main/src/main/java/minetweaker/mc164/oredict/MCOreDictEntry.java +++ b/MineTweaker3-MC164-Main/src/main/java/minetweaker/mc164/oredict/MCOreDictEntry.java @@ -7,6 +7,7 @@ package minetweaker.mc164.oredict; import java.util.ArrayList; +import java.util.Collections; import java.util.List; import minetweaker.IUndoableAction; import minetweaker.MineTweakerAPI; @@ -17,6 +18,7 @@ import minetweaker.api.item.IItemStack; import minetweaker.api.item.IItemTransformer; import minetweaker.api.item.IngredientOr; import minetweaker.api.item.IngredientStack; +import minetweaker.api.liquid.ILiquidStack; import static minetweaker.api.minecraft.MineTweakerMC.getIItemStackWildcardSize; import static minetweaker.api.minecraft.MineTweakerMC.getItemStack; import minetweaker.api.oredict.IOreDictEntry; @@ -127,6 +129,11 @@ public class MCOreDictEntry implements IOreDictEntry { } return result; } + + @Override + public List getLiquids() { + return Collections.emptyList(); + } @Override public IIngredient amount(int amount) { @@ -157,6 +164,11 @@ public class MCOreDictEntry implements IOreDictEntry { public boolean matches(IItemStack item) { return contains(item); } + + @Override + public boolean matches(ILiquidStack liquid) { + return false; + } @Override public boolean contains(IIngredient ingredient) { diff --git a/MineTweaker3-MC164-Main/src/main/java/minetweaker/mc164/recipes/MCRecipeManager.java b/MineTweaker3-MC164-Main/src/main/java/minetweaker/mc164/recipes/MCRecipeManager.java index 5ee8ac3..5eb12f9 100644 --- a/MineTweaker3-MC164-Main/src/main/java/minetweaker/mc164/recipes/MCRecipeManager.java +++ b/MineTweaker3-MC164-Main/src/main/java/minetweaker/mc164/recipes/MCRecipeManager.java @@ -326,7 +326,8 @@ public class MCRecipeManager implements IRecipeManager { @Override public void undo() { for (int i = 0; i < removingIndices.size(); i++) { - recipes.add(removingIndices.get(i), removingRecipes.get(i)); + int index = Math.min(recipes.size(), removingIndices.get(i)); + recipes.add(index, removingRecipes.get(i)); } } diff --git a/MineTweaker3-MC1710-Main/src/main/java/minetweaker/api/minecraft/MineTweakerMC.java b/MineTweaker3-MC1710-Main/src/main/java/minetweaker/api/minecraft/MineTweakerMC.java index cfe2f9e..5e984c6 100644 --- a/MineTweaker3-MC1710-Main/src/main/java/minetweaker/api/minecraft/MineTweakerMC.java +++ b/MineTweaker3-MC1710-Main/src/main/java/minetweaker/api/minecraft/MineTweakerMC.java @@ -23,6 +23,7 @@ import minetweaker.mc1710.oredict.MCOreDictEntry; import minetweaker.mc1710.player.MCPlayer; import minetweaker.mc1710.world.MCDimension; import minetweaker.mc1710.block.MCWorldBlock; +import minetweaker.mc1710.liquid.MCLiquidStack; import minetweaker.mc1710.world.MCBiome; import net.minecraft.block.Block; import net.minecraft.entity.player.EntityPlayer; @@ -447,6 +448,8 @@ public class MineTweakerMC { } return entry; + } else if (ingredient instanceof FluidStack) { + return new MCLiquidStack((FluidStack) ingredient); } else { throw new IllegalArgumentException("Not a valid ingredient: " + ingredient); } diff --git a/MineTweaker3-MC1710-Main/src/main/java/minetweaker/mc1710/item/MCItemStack.java b/MineTweaker3-MC1710-Main/src/main/java/minetweaker/mc1710/item/MCItemStack.java index a5ac720..65ca772 100644 --- a/MineTweaker3-MC1710-Main/src/main/java/minetweaker/mc1710/item/MCItemStack.java +++ b/MineTweaker3-MC1710-Main/src/main/java/minetweaker/mc1710/item/MCItemStack.java @@ -203,6 +203,11 @@ public class MCItemStack implements IItemStack { public List getItems() { return items; } + + @Override + public List getLiquids() { + return Collections.emptyList(); + } @Override public IItemStack amount(int amount) { @@ -248,6 +253,11 @@ public class MCItemStack implements IItemStack { || stack.getItemDamage() == internal.getItemDamage() || (!stack.getHasSubtypes() && !stack.getItem().isDamageable())); } + + @Override + public boolean matches(ILiquidStack liquid) { + return false; + } @Override public boolean contains(IIngredient ingredient) { diff --git a/MineTweaker3-MC1710-Main/src/main/java/minetweaker/mc1710/liquid/MCLiquidStack.java b/MineTweaker3-MC1710-Main/src/main/java/minetweaker/mc1710/liquid/MCLiquidStack.java index 2ce9271..3dcb1c9 100644 --- a/MineTweaker3-MC1710-Main/src/main/java/minetweaker/mc1710/liquid/MCLiquidStack.java +++ b/MineTweaker3-MC1710-Main/src/main/java/minetweaker/mc1710/liquid/MCLiquidStack.java @@ -6,10 +6,18 @@ package minetweaker.mc1710.liquid; +import java.util.Collections; +import java.util.List; import minetweaker.mc1710.data.NBTConverter; import minetweaker.api.data.IData; +import minetweaker.api.item.IIngredient; +import minetweaker.api.item.IItemCondition; +import minetweaker.api.item.IItemStack; +import minetweaker.api.item.IItemTransformer; +import minetweaker.api.item.IngredientOr; import minetweaker.api.liquid.ILiquidDefinition; import minetweaker.api.liquid.ILiquidStack; +import minetweaker.api.player.IPlayer; import net.minecraft.nbt.NBTTagCompound; import net.minecraftforge.fluids.FluidStack; @@ -106,4 +114,96 @@ public class MCLiquidStack implements ILiquidStack { public Object getInternal() { return stack; } + + // ################################## + // ### IIngredient implementation ### + // ################################## + + @Override + public String getMark() + { + return null; + } + + @Override + public List getItems() + { + return Collections.emptyList(); + } + + @Override + public List getLiquids() + { + return Collections.singletonList(this); + } + + @Override + public IIngredient amount(int amount) + { + return withAmount(amount); + } + + @Override + public IIngredient or(IIngredient ingredient) + { + return new IngredientOr(this, ingredient); + } + + @Override + public IIngredient transform(IItemTransformer transformer) + { + throw new UnsupportedOperationException("Liquid stack can't have transformers"); + } + + @Override + public IIngredient only(IItemCondition condition) + { + throw new UnsupportedOperationException("Liquid stack can't have conditions"); + } + + @Override + public IIngredient marked(String mark) + { + throw new UnsupportedOperationException("Liquid stack can't be marked"); + } + + @Override + public boolean matches(IItemStack item) + { + return false; + } + + @Override + public boolean matches(ILiquidStack liquid) + { + return getDefinition().equals(liquid.getDefinition()) + && getAmount() <= liquid.getAmount(); + } + + @Override + public boolean contains(IIngredient ingredient) + { + if (!ingredient.getItems().isEmpty()) + return false; + + for (ILiquidStack liquid : ingredient.getLiquids()) + { + if (!matches(liquid)) + return false; + } + + return false; + } + + @Override + public IItemStack applyTransform(IItemStack item, IPlayer byPlayer) + { + return item; + } + + @Override + public boolean hasTransformers() + { + return false; + } } diff --git a/MineTweaker3-MC1710-Main/src/main/java/minetweaker/mc1710/oredict/MCOreDictEntry.java b/MineTweaker3-MC1710-Main/src/main/java/minetweaker/mc1710/oredict/MCOreDictEntry.java index bba5028..941dc88 100644 --- a/MineTweaker3-MC1710-Main/src/main/java/minetweaker/mc1710/oredict/MCOreDictEntry.java +++ b/MineTweaker3-MC1710-Main/src/main/java/minetweaker/mc1710/oredict/MCOreDictEntry.java @@ -7,6 +7,7 @@ package minetweaker.mc1710.oredict; import java.util.ArrayList; +import java.util.Collections; import java.util.List; import minetweaker.IUndoableAction; import minetweaker.MineTweakerAPI; @@ -17,6 +18,7 @@ import minetweaker.api.item.IItemStack; import minetweaker.api.item.IItemTransformer; import minetweaker.api.item.IngredientOr; import minetweaker.api.item.IngredientStack; +import minetweaker.api.liquid.ILiquidStack; import static minetweaker.api.minecraft.MineTweakerMC.getIItemStackWildcardSize; import static minetweaker.api.minecraft.MineTweakerMC.getItemStack; import minetweaker.api.oredict.IOreDictEntry; @@ -128,6 +130,11 @@ public class MCOreDictEntry implements IOreDictEntry { } return result; } + + @Override + public List getLiquids() { + return Collections.emptyList(); + } @Override public IIngredient amount(int amount) { @@ -158,6 +165,11 @@ public class MCOreDictEntry implements IOreDictEntry { public boolean matches(IItemStack item) { return contains(item); } + + @Override + public boolean matches(ILiquidStack liquid) { + return false; + } @Override public boolean contains(IIngredient ingredient) { diff --git a/MineTweaker3-MC1710-Main/src/main/java/minetweaker/mc1710/recipes/MCRecipeManager.java b/MineTweaker3-MC1710-Main/src/main/java/minetweaker/mc1710/recipes/MCRecipeManager.java index 9632953..597bc9e 100644 --- a/MineTweaker3-MC1710-Main/src/main/java/minetweaker/mc1710/recipes/MCRecipeManager.java +++ b/MineTweaker3-MC1710-Main/src/main/java/minetweaker/mc1710/recipes/MCRecipeManager.java @@ -326,7 +326,8 @@ public class MCRecipeManager implements IRecipeManager { @Override public void undo() { for (int i = 0; i < removingIndices.size(); i++) { - recipes.add(removingIndices.get(i), removingRecipes.get(i)); + int index = Math.min(recipes.size(), removingIndices.get(i)); + recipes.add(index, removingRecipes.get(i)); } } diff --git a/MineTweaker3-MC1710-Mod-Buildcraft/libs/buildcraft-6.1.5-dev.jar b/MineTweaker3-MC1710-Mod-Buildcraft/libs/buildcraft-6.1.5-dev.jar new file mode 100644 index 0000000..0e0c659 Binary files /dev/null and b/MineTweaker3-MC1710-Mod-Buildcraft/libs/buildcraft-6.1.5-dev.jar differ diff --git a/MineTweaker3-MC1710-Mod-Buildcraft/src/main/java/minetweaker/mods/buildcraft/AssemblyTable.java b/MineTweaker3-MC1710-Mod-Buildcraft/src/main/java/minetweaker/mods/buildcraft/AssemblyTable.java index e20cb57..712cc7c 100644 --- a/MineTweaker3-MC1710-Mod-Buildcraft/src/main/java/minetweaker/mods/buildcraft/AssemblyTable.java +++ b/MineTweaker3-MC1710-Mod-Buildcraft/src/main/java/minetweaker/mods/buildcraft/AssemblyTable.java @@ -1,3 +1,4 @@ + /* * To change this license header, choose License Headers in Project Properties. * To change this template file, choose Tools | Templates @@ -27,7 +28,7 @@ import stanhebben.zenscript.annotations.ZenMethod; * @author Stan */ @ZenClass("mods.buildcraft.AssemblyTable") -@ModOnly("BuildCraft|Core") +@ModOnly(value="BuildCraft|Core", version="6.0") public class AssemblyTable { @ZenMethod public static void addRecipe(IItemStack output, double energy, IIngredient[] ingredients) { diff --git a/MineTweaker3-MC1710-Mod-Buildcraft/src/main/java/minetweaker/mods/buildcraft/Fuels.java b/MineTweaker3-MC1710-Mod-Buildcraft/src/main/java/minetweaker/mods/buildcraft/Fuels.java index 5053306..fd1a556 100644 --- a/MineTweaker3-MC1710-Mod-Buildcraft/src/main/java/minetweaker/mods/buildcraft/Fuels.java +++ b/MineTweaker3-MC1710-Mod-Buildcraft/src/main/java/minetweaker/mods/buildcraft/Fuels.java @@ -30,7 +30,7 @@ import stanhebben.zenscript.annotations.ZenMethod; * @author Stan */ @ZenClass("mods.buildcraft.Fuels") -@ModOnly("BuildCraft|Core") +@ModOnly(value="BuildCraft|Core", version="6.0") public class Fuels { private static final Constructor CONSTRUCT_FUEL; diff --git a/MineTweaker3-MC1710-Mod-Buildcraft/src/main/java/minetweaker/mods/buildcraft/IntegrationTable.java b/MineTweaker3-MC1710-Mod-Buildcraft/src/main/java/minetweaker/mods/buildcraft/IntegrationTable.java index f55ee76..8ae5607 100644 --- a/MineTweaker3-MC1710-Mod-Buildcraft/src/main/java/minetweaker/mods/buildcraft/IntegrationTable.java +++ b/MineTweaker3-MC1710-Mod-Buildcraft/src/main/java/minetweaker/mods/buildcraft/IntegrationTable.java @@ -26,7 +26,7 @@ import stanhebben.zenscript.annotations.ZenMethod; * @author Stan */ @ZenClass("mods.buildcraft.IntegrationTable") -@ModOnly("BuildCraft|Core") +@ModOnly(value="BuildCraft|Core", version="6.0") public class IntegrationTable { @ZenMethod public static void addRecipe(IItemStack output, double energy, IIngredient inputA, IIngredient inputB, @Optional IIntegrationRecipeFunction function) { diff --git a/MineTweaker3-MC1710-Mod-Buildcraft/src/main/java/minetweaker/mods/buildcraft/Refinery.java b/MineTweaker3-MC1710-Mod-Buildcraft/src/main/java/minetweaker/mods/buildcraft/Refinery.java index b281ad1..69f4c8f 100644 --- a/MineTweaker3-MC1710-Mod-Buildcraft/src/main/java/minetweaker/mods/buildcraft/Refinery.java +++ b/MineTweaker3-MC1710-Mod-Buildcraft/src/main/java/minetweaker/mods/buildcraft/Refinery.java @@ -33,7 +33,7 @@ import stanhebben.zenscript.annotations.ZenMethod; * @author Stan */ @ZenClass("mods.buildcraft.Refinery") -@ModOnly("BuildCraft|Core") +@ModOnly(value="BuildCraft|Core", version="6.0") public class Refinery { private static final Constructor CONSTRUCT_REFINERYRECIPE; private static final Field REFINERYRECIPEMANAGER_RECIPES; diff --git a/MineTweaker3-MC1710-Mod-Buildcraft61/build.gradle b/MineTweaker3-MC1710-Mod-Buildcraft61/build.gradle new file mode 100644 index 0000000..a8cd99b --- /dev/null +++ b/MineTweaker3-MC1710-Mod-Buildcraft61/build.gradle @@ -0,0 +1,42 @@ +import minetweaker.tasks.RegisterZenClassesTask; + +buildscript { + repositories { + mavenCentral() + maven { + name = "forge" + url = "http://files.minecraftforge.net/maven" + } + maven { + name = "sonatype" + url = "https://oss.sonatype.org/content/repositories/snapshots/" + } + } + dependencies { + classpath 'net.minecraftforge.gradle:ForgeGradle:1.2-SNAPSHOT' + } +} + +apply plugin: 'forge' + +minecraft { + version = forgeVersion1710 +} + +version = "1.0" +archivesBaseName = project.projectDir.name + +dependencies { + compile project(':ZenScript') + compile project(':MineTweaker3-API') + compile project(':MineTweaker3-MC1710-Main') + compile files('libs/buildcraft-6.1.5-dev.jar') +} + +task makeRegistry(type: RegisterZenClassesTask) { + inputDir = file('build/classes/main') + outputDir = file('build/classes/main') + className = 'minetweaker.mods.buildcraft.ClassRegistry' +} + +tasks.jar.dependsOn(makeRegistry) diff --git a/MineTweaker3-MC1710-Mod-Buildcraft61/libs/buildcraft-6.1.5-dev.jar b/MineTweaker3-MC1710-Mod-Buildcraft61/libs/buildcraft-6.1.5-dev.jar new file mode 100644 index 0000000..0e0c659 Binary files /dev/null and b/MineTweaker3-MC1710-Mod-Buildcraft61/libs/buildcraft-6.1.5-dev.jar differ diff --git a/MineTweaker3-MC1710-Mod-Buildcraft61/src/main/java/minetweaker/mods/buildcraft61/AssemblyTable.java b/MineTweaker3-MC1710-Mod-Buildcraft61/src/main/java/minetweaker/mods/buildcraft61/AssemblyTable.java new file mode 100644 index 0000000..58c298a --- /dev/null +++ b/MineTweaker3-MC1710-Mod-Buildcraft61/src/main/java/minetweaker/mods/buildcraft61/AssemblyTable.java @@ -0,0 +1,138 @@ + +/* + * To change this license header, choose License Headers in Project Properties. + * To change this template file, choose Tools | Templates + * and open the template in the editor. + */ + +package minetweaker.mods.buildcraft61; + +import buildcraft.api.recipes.BuildcraftRecipeRegistry; +import buildcraft.api.recipes.IFlexibleRecipe; +import buildcraft.core.recipes.FlexibleRecipe; +import java.util.List; +import minetweaker.IUndoableAction; +import minetweaker.MineTweakerAPI; +import minetweaker.annotations.ModOnly; +import minetweaker.api.item.IIngredient; +import minetweaker.api.item.IItemStack; +import minetweaker.api.minecraft.MineTweakerMC; +import net.minecraft.item.ItemStack; +import stanhebben.zenscript.annotations.Optional; +import stanhebben.zenscript.annotations.ZenClass; +import stanhebben.zenscript.annotations.ZenMethod; + +/** + * + * @author Stan + */ +@ZenClass("mods.buildcraft.AssemblyTable") +@ModOnly(value="BuildCraft|Core", version="6.1") +public class AssemblyTable { + @ZenMethod + public static void addRecipe(IItemStack output, double energy, IIngredient[] ingredients) { + MineTweakerAPI.apply(new AddRecipeAction(output, energy, ingredients)); + } + + @ZenMethod + public static void remove(IIngredient output) { + removeRecipe(output, null, false); + } + + @ZenMethod + public static void removeRecipe(IIngredient output, @Optional IIngredient[] ingredients, @Optional boolean wildcard) { + List> toRemove = BuildcraftRecipes.removeRecipes( + output, + ingredients, + BuildcraftRecipeRegistry.assemblyTable.getRecipes()); + + for (IFlexibleRecipe recipe : toRemove) { + ItemStack recipeOutput = recipe instanceof FlexibleRecipe ? (ItemStack)(((FlexibleRecipe) recipe).output) : null; + MineTweakerAPI.apply(new RemoveRecipeAction(recipe, recipeOutput)); + } + } + + // ###################### + // ### Action classes ### + // ###################### + + private static class AddRecipeAction implements IUndoableAction { + private final IItemStack output; + private final IFlexibleRecipe recipe; + + public AddRecipeAction(IItemStack output, double energy, IIngredient[] ingredients) { + this.output = output; + this.recipe = new MTFlexibleRecipe(output, ingredients, (int) energy, 0); + } + + @Override + public void apply() { + BuildcraftRecipeRegistry.assemblyTable.addRecipe(recipe); + } + + @Override + public boolean canUndo() { + return true; + } + + @Override + public void undo() { + BuildcraftRecipeRegistry.assemblyTable.removeRecipe(recipe); + } + + @Override + public String describe() { + return "Adding assembly table recipe for " + output; + } + + @Override + public String describeUndo() { + return "Removing assembly table recipe for " + output; + } + + @Override + public Object getOverrideKey() { + return null; + } + } + + private static class RemoveRecipeAction implements IUndoableAction { + private final IFlexibleRecipe recipe; + private final ItemStack output; + + public RemoveRecipeAction(IFlexibleRecipe recipe, ItemStack output) { + this.recipe = recipe; + this.output = output; + } + + @Override + public void apply() { + BuildcraftRecipeRegistry.assemblyTable.removeRecipe(recipe); + } + + @Override + public boolean canUndo() { + return true; + } + + @Override + public void undo() { + BuildcraftRecipeRegistry.assemblyTable.addRecipe(recipe); + } + + @Override + public String describe() { + return "Removing assembly table recipe for " + MineTweakerMC.getIItemStack(output); + } + + @Override + public String describeUndo() { + return "Restoring assembly table recipe for " + MineTweakerMC.getIItemStack(output); + } + + @Override + public Object getOverrideKey() { + return null; + } + } +} diff --git a/MineTweaker3-MC1710-Mod-Buildcraft61/src/main/java/minetweaker/mods/buildcraft61/BuildcraftRecipes.java b/MineTweaker3-MC1710-Mod-Buildcraft61/src/main/java/minetweaker/mods/buildcraft61/BuildcraftRecipes.java new file mode 100644 index 0000000..9c42074 --- /dev/null +++ b/MineTweaker3-MC1710-Mod-Buildcraft61/src/main/java/minetweaker/mods/buildcraft61/BuildcraftRecipes.java @@ -0,0 +1,65 @@ +/* + * To change this license header, choose License Headers in Project Properties. + * To change this template file, choose Tools | Templates + * and open the template in the editor. + */ +package minetweaker.mods.buildcraft61; + +import buildcraft.api.recipes.IFlexibleRecipe; +import buildcraft.core.recipes.FlexibleRecipe; +import java.util.ArrayList; +import java.util.Collection; +import java.util.List; +import minetweaker.api.item.IIngredient; +import minetweaker.api.item.IngredientAny; +import minetweaker.api.minecraft.MineTweakerMC; +import net.minecraft.item.ItemStack; + +/** + * + * @author Stan + */ +public class BuildcraftRecipes +{ + private BuildcraftRecipes() {} + + public static List> removeRecipes(IIngredient output, IIngredient[] inputs, Collection> recipes) + { + if (output == IngredientAny.INSTANCE && (inputs == null || inputs.length == 0)) + return new ArrayList>(recipes); + + List> results = new ArrayList>(); + for (IFlexibleRecipe recipe : recipes) { + if (recipe instanceof FlexibleRecipe && matches(output, inputs, (FlexibleRecipe) recipe)) + results.add(recipe); + } + + return results; + } + + private static boolean matches(IIngredient output, IIngredient[] inputs, FlexibleRecipe recipe) + { + ItemStack recipeOutput = (ItemStack) recipe.getOutput(); + if (!output.matches(MineTweakerMC.getIItemStack(recipeOutput))) + return false; + + if (inputs == null || inputs.length == 0) + return true; + + boolean[] matches = new boolean[inputs.length]; + outer: for (Object recipeInputObject : recipe.getInputs()) + { + IIngredient recipeIngredient = MineTweakerMC.getIIngredient(recipeInputObject); + for (int i = 0; i < inputs.length; i++) { + if (!matches[i] && inputs[i].contains(recipeIngredient)) + { + matches[i] = true; + continue outer; + } + } + return false; + } + + return true; + } +} diff --git a/MineTweaker3-MC1710-Mod-Buildcraft61/src/main/java/minetweaker/mods/buildcraft61/IIntegrationRecipeFunction.java b/MineTweaker3-MC1710-Mod-Buildcraft61/src/main/java/minetweaker/mods/buildcraft61/IIntegrationRecipeFunction.java new file mode 100644 index 0000000..a1bd6b3 --- /dev/null +++ b/MineTweaker3-MC1710-Mod-Buildcraft61/src/main/java/minetweaker/mods/buildcraft61/IIntegrationRecipeFunction.java @@ -0,0 +1,17 @@ +/* + * To change this license header, choose License Headers in Project Properties. + * To change this template file, choose Tools | Templates + * and open the template in the editor. + */ + +package minetweaker.mods.buildcraft61; + +import minetweaker.api.item.IItemStack; + +/** + * + * @author Stan + */ +public interface IIntegrationRecipeFunction { + public IItemStack recipe(IItemStack output, IItemStack inputA, IItemStack inputB); +} diff --git a/MineTweaker3-MC1710-Mod-Buildcraft61/src/main/java/minetweaker/mods/buildcraft61/IntegrationTable.java b/MineTweaker3-MC1710-Mod-Buildcraft61/src/main/java/minetweaker/mods/buildcraft61/IntegrationTable.java new file mode 100644 index 0000000..46db9ba --- /dev/null +++ b/MineTweaker3-MC1710-Mod-Buildcraft61/src/main/java/minetweaker/mods/buildcraft61/IntegrationTable.java @@ -0,0 +1,237 @@ +/* + * To change this license header, choose License Headers in Project Properties. + * To change this template file, choose Tools | Templates + * and open the template in the editor. + */ + +package minetweaker.mods.buildcraft61; + +import buildcraft.api.recipes.BuildcraftRecipeRegistry; +import buildcraft.api.recipes.CraftingResult; +import buildcraft.api.recipes.IFlexibleCrafter; +import buildcraft.api.recipes.IIntegrationRecipe; +import minetweaker.IUndoableAction; +import minetweaker.MineTweakerAPI; +import minetweaker.annotations.ModOnly; +import minetweaker.api.item.IIngredient; +import minetweaker.api.item.IItemStack; +import minetweaker.api.minecraft.MineTweakerMC; +import net.minecraft.item.ItemStack; +import stanhebben.zenscript.annotations.Optional; +import stanhebben.zenscript.annotations.ZenClass; +import stanhebben.zenscript.annotations.ZenMethod; + +/** + * + * @author Stan + */ +@ZenClass("mods.buildcraft.IntegrationTable") +@ModOnly(value="BuildCraft|Core", version="6.1") +public class IntegrationTable { + @ZenMethod + public static void addRecipe(IItemStack output, double energy, IIngredient inputA, IIngredient inputB, @Optional IIntegrationRecipeFunction function) { + MineTweakerAPI.apply(new AddRecipeAction(output, energy, inputA, inputB, function)); + } + + /*@ZenMethod + public static void remove(IIngredient output) { + removeRecipe(output, null, null); + }*/ + + /*@ZenMethod + public static void removeRecipe(IIngredient output, @Optional IIngredient inputA, @Optional IIngredient inputB) { + IIngredient[] ingredients = null; + if (inputA != null && inputB != null) { + ingredients = new IIngredient[] { inputA, inputB }; + } else if (inputA != null) { + ingredients = new IIngredient[] { inputA }; + } else if (inputB != null) { + ingredients = new IIngredient[] { inputB }; + } + + List recipes = BuildcraftRecipeRegistry.integrationTable.getRecipes(); + List> toRemove = BuildcraftRecipes.removeRecipes(output, ingredients, recipes); + + for (IFlexibleRecipe recipe : toRemove) { + MineTweakerAPI.apply(new RemoveRecipeAction(recipe)); + } + }*/ + + // ###################### + // ### Action Classes ### + // ###################### + + private static class AddRecipeAction implements IUndoableAction { + private final MTIntegrationRecipe recipe; + + public AddRecipeAction(IItemStack output, double energy, IIngredient inputA, IIngredient inputB, IIntegrationRecipeFunction function) { + recipe = new MTIntegrationRecipe(output, energy, inputA, inputB, function); + } + + @Override + public void apply() { + BuildcraftRecipeRegistry.integrationTable.addRecipe(recipe); + } + + @Override + public boolean canUndo() { + return true; + } + + @Override + public void undo() { + BuildcraftRecipeRegistry.integrationTable.getRecipes().remove(recipe); + } + + @Override + public String describe() { + return "Adding integration table recipe for " + recipe.output; + } + + @Override + public String describeUndo() { + return "Removing integration table recipe for " + recipe.output; + } + + @Override + public Object getOverrideKey() { + return null; + } + } + /* + private static class RemoveRecipeAction implements IUndoableAction { + private final IFlexibleRecipe recipe; + + public RemoveRecipeAction(IFlexibleRecipe recipe) { + this.recipe = recipe; + } + + @Override + public void apply() { + BuildcraftRecipeRegistry.integrationTable.getRecipes().remove(recipe); + } + + @Override + public boolean canUndo() { + return true; + } + + @Override + public void undo() { + BuildcraftRecipeRegistry.integrationTable.getRecipes().add((IIntegrationRecipe) recipe); + } + + @Override + public String describe() { + return "Removing integration table recipe for " + MineTweakerMC.getIItemStack(recipe.getComponents()[0]); + } + + @Override + public String describeUndo() { + return "Restoring integration table recipe for " + MineTweakerMC.getIItemStack(recipe.getComponents()[0]); + } + + @Override + public Object getOverrideKey() { + return null; + } + }*/ + + private static class MTIntegrationRecipe implements IIntegrationRecipe { + private static int idCounter = 0; + + private final String id; + private final IItemStack output; + private final ItemStack[] components; + private final double energy; + private final IIngredient inputA; + private final ItemStack[] inputAExamples; + private final IIngredient inputB; + private final ItemStack[] inputBExamples; + private final IIntegrationRecipeFunction function; + + private MTIntegrationRecipe(IItemStack output, double energy, IIngredient inputA, IIngredient inputB, IIntegrationRecipeFunction function) { + this.id = "mtIntegration" + (idCounter++); + this.output = output; + this.components = new ItemStack[] { MineTweakerMC.getItemStack(output) }; + this.energy = energy; + this.inputA = inputA; + this.inputAExamples = MineTweakerMC.getExamples(inputA); + this.inputB = inputB; + this.inputBExamples = MineTweakerMC.getExamples(inputB); + this.function = function; + } + + @Override + public String getId() { + return id; + } + + @Override + public boolean isValidInputA(ItemStack is) { + return inputA.matches(MineTweakerMC.getIItemStack(is)); + } + + @Override + public boolean isValidInputB(ItemStack is) { + return inputB.matches(MineTweakerMC.getIItemStack(is)); + } + + /*@Override + public ItemStack getOutputForInputs(ItemStack is, ItemStack is1, ItemStack[] iss) { + if (function != null) { + IItemStack actualInputA = MineTweakerMC.getIItemStack(is); + IItemStack actualInputB = MineTweakerMC.getIItemStack(is1); + return MineTweakerMC.getItemStack(function.recipe(output, actualInputA, actualInputB)); + } else { + return MineTweakerMC.getItemStack(output); + } + }*/ + + @Override + public boolean canBeCrafted(IFlexibleCrafter ifc) + { + return inputA.matches(MineTweakerMC.getIItemStack(ifc.getCraftingItemStack(0))) + && (inputB == null || inputB.matches(MineTweakerMC.getIItemStack(ifc.getCraftingItemStack(1)))); + } + + @Override + public CraftingResult craft(IFlexibleCrafter ifc, boolean bln) + { + if (!canBeCrafted(ifc)) + return null; + + CraftingResult result = new CraftingResult(); + result.crafted = MineTweakerMC.getItemStack(output); + + ItemStack consumedA = new ItemStack(ifc.getCraftingItemStack(0).getItem(), inputA.getAmount(), ifc.getCraftingItemStack(0).getItemDamage()); + consumedA.setTagCompound(ifc.getCraftingItemStack(0).stackTagCompound); + result.usedItems.add(consumedA); + + if (inputB != null) { + ItemStack consumedB = new ItemStack(ifc.getCraftingItemStack(1).getItem(), inputB.getAmount(), ifc.getCraftingItemStack(0).getItemDamage()); + consumedB.setTagCompound(ifc.getCraftingItemStack(1).stackTagCompound); + result.usedItems.add(consumedB); + } + + return result; + } + + @Override + public CraftingResult canCraft(ItemStack is) + { + if (inputB != null) + return null; + + if (!inputA.matches(MineTweakerMC.getIItemStack(is))) + return null; + + CraftingResult result = new CraftingResult(); + result.crafted = MineTweakerMC.getItemStack(output); + ItemStack consumed = new ItemStack(is.getItem(), inputA.getAmount(), is.getItemDamage()); + consumed.setTagCompound(is.stackTagCompound); + result.usedItems.add(consumed); + return result; + } + } +} diff --git a/MineTweaker3-MC1710-Mod-Buildcraft61/src/main/java/minetweaker/mods/buildcraft61/MTFlexibleRecipe.java b/MineTweaker3-MC1710-Mod-Buildcraft61/src/main/java/minetweaker/mods/buildcraft61/MTFlexibleRecipe.java new file mode 100644 index 0000000..6e9e37b --- /dev/null +++ b/MineTweaker3-MC1710-Mod-Buildcraft61/src/main/java/minetweaker/mods/buildcraft61/MTFlexibleRecipe.java @@ -0,0 +1,144 @@ +/* + * To change this license header, choose License Headers in Project Properties. + * To change this template file, choose Tools | Templates + * and open the template in the editor. + */ +package minetweaker.mods.buildcraft61; + +import buildcraft.api.recipes.CraftingResult; +import buildcraft.api.recipes.IFlexibleCrafter; +import buildcraft.api.recipes.IFlexibleRecipe; +import java.util.ArrayList; +import java.util.List; +import minetweaker.api.item.IIngredient; +import minetweaker.api.item.IItemStack; +import minetweaker.api.liquid.ILiquidStack; +import minetweaker.api.minecraft.MineTweakerMC; +import minetweaker.mc1710.liquid.MCLiquidStack; +import net.minecraft.item.ItemStack; + +/** + * + * @author Stan + */ +public class MTFlexibleRecipe implements IFlexibleRecipe +{ + private static int idCounter = 0; + + private final String id; + private final IItemStack output; + private final IIngredient[] inputs; + private final int energyCost; + private final long craftingTime; + + public MTFlexibleRecipe(IItemStack output, IIngredient[] inputs, int energyCost, long craftingTime) + { + if (inputs.length == 0) + throw new IllegalArgumentException("recipe must have at least 1 input"); + + this.id = "minetweaker" + (idCounter++); + this.output = output; + this.inputs = inputs; + this.energyCost = energyCost; + this.craftingTime = craftingTime; + } + + @Override + public boolean canBeCrafted(IFlexibleCrafter ifc) + { + List items = new ArrayList(); + for (int i = 0; i < ifc.getCraftingItemStackSize(); i++) { + if (ifc.getCraftingItemStack(i) != null) + items.add(MineTweakerMC.getIItemStack(ifc.getCraftingItemStack(i))); + } + + List liquids = new ArrayList(); + for (int i = 0; i < ifc.getCraftingFluidStackSize(); i++) { + if (ifc.getCraftingFluidStack(i) != null) + liquids.add(new MCLiquidStack(ifc.getCraftingFluidStack(i))); + } + + outer: for (IIngredient ingredient : inputs) { + for (IItemStack item : items) { + if (ingredient.matches(item)) + continue outer; + } + + for (ILiquidStack liquid : liquids) { + if (ingredient.matches(liquid)) + continue outer; + } + + return false; + } + + return true; + } + + @Override + public CraftingResult craft(IFlexibleCrafter ifc, boolean preview) + { + CraftingResult result = new CraftingResult(); + + List items = new ArrayList(); + for (int i = 0; i < ifc.getCraftingItemStackSize(); i++) { + if (ifc.getCraftingItemStack(i) != null) + items.add(MineTweakerMC.getIItemStack(ifc.getCraftingItemStack(i))); + } + + List liquids = new ArrayList(); + for (int i = 0; i < ifc.getCraftingFluidStackSize(); i++) { + if (ifc.getCraftingFluidStack(i) != null) + liquids.add(new MCLiquidStack(ifc.getCraftingFluidStack(i))); + } + + result.energyCost = energyCost; + result.craftingTime = craftingTime; + + outer: for (IIngredient ingredient : inputs) { + for (IItemStack item : items) { + if (ingredient.matches(item)) { + result.usedItems.add(MineTweakerMC.getItemStack(item.withAmount(ingredient.getAmount()))); + continue outer; + } + } + + for (ILiquidStack liquid : liquids) { + if (ingredient.matches(liquid)) { + result.usedFluids.add(MineTweakerMC.getLiquidStack(liquid.withAmount(ingredient.getAmount()))); + continue outer; + } + } + + return null; + } + + return result; + } + + @Override + public CraftingResult canCraft(ItemStack is) + { + if (!output.matches(MineTweakerMC.getIItemStack(is))) + return null; + + /*if (inputs.length > 1) + return null; + + if (!inputs[0].matches(MineTweakerMC.getIItemStack(is))) + return null;*/ + + CraftingResult result = new CraftingResult(); + result.crafted = MineTweakerMC.getItemStack(output); + ItemStack consumed = new ItemStack(is.getItem(), inputs[0].getAmount(), is.getItemDamage()); + consumed.setTagCompound(is.stackTagCompound); + result.usedItems.add(consumed); + return result; + } + + @Override + public String getId() + { + return id; + } +} diff --git a/MineTweaker3-MC172-Main/src/main/java/minetweaker/mc172/item/MCItemStack.java b/MineTweaker3-MC172-Main/src/main/java/minetweaker/mc172/item/MCItemStack.java index bc4c44a..20f1807 100644 --- a/MineTweaker3-MC172-Main/src/main/java/minetweaker/mc172/item/MCItemStack.java +++ b/MineTweaker3-MC172-Main/src/main/java/minetweaker/mc172/item/MCItemStack.java @@ -203,6 +203,11 @@ public class MCItemStack implements IItemStack { public List getItems() { return items; } + + @Override + public List getLiquids() { + return Collections.emptyList(); + } @Override public IItemStack amount(int amount) { @@ -248,6 +253,11 @@ public class MCItemStack implements IItemStack { || stack.getItemDamage() == internal.getItemDamage() || (!stack.getHasSubtypes() && !stack.getItem().isDamageable())); } + + @Override + public boolean matches(ILiquidStack liquid) { + return false; + } @Override public boolean contains(IIngredient ingredient) { diff --git a/MineTweaker3-MC172-Main/src/main/java/minetweaker/mc172/liquid/MCLiquidStack.java b/MineTweaker3-MC172-Main/src/main/java/minetweaker/mc172/liquid/MCLiquidStack.java index 2303141..e88e839 100644 --- a/MineTweaker3-MC172-Main/src/main/java/minetweaker/mc172/liquid/MCLiquidStack.java +++ b/MineTweaker3-MC172-Main/src/main/java/minetweaker/mc172/liquid/MCLiquidStack.java @@ -6,11 +6,19 @@ package minetweaker.mc172.liquid; +import java.util.Collections; +import java.util.List; import minetweaker.api.data.IData; +import minetweaker.api.item.IIngredient; +import minetweaker.api.item.IItemCondition; +import minetweaker.api.item.IItemStack; +import minetweaker.api.item.IItemTransformer; +import minetweaker.api.item.IngredientOr; import minetweaker.api.liquid.ILiquidDefinition; import minetweaker.api.liquid.ILiquidStack; import static minetweaker.api.minecraft.MineTweakerMC.getIData; import static minetweaker.api.minecraft.MineTweakerMC.getNBTCompound; +import minetweaker.api.player.IPlayer; import net.minecraftforge.fluids.FluidStack; /** @@ -106,4 +114,96 @@ public class MCLiquidStack implements ILiquidStack { public Object getInternal() { return stack; } + + // ################################## + // ### IIngredient implementation ### + // ################################## + + @Override + public String getMark() + { + return null; + } + + @Override + public List getItems() + { + return Collections.emptyList(); + } + + @Override + public List getLiquids() + { + return Collections.singletonList(this); + } + + @Override + public IIngredient amount(int amount) + { + return withAmount(amount); + } + + @Override + public IIngredient or(IIngredient ingredient) + { + return new IngredientOr(this, ingredient); + } + + @Override + public IIngredient transform(IItemTransformer transformer) + { + throw new UnsupportedOperationException("Liquid stack can't have transformers"); + } + + @Override + public IIngredient only(IItemCondition condition) + { + throw new UnsupportedOperationException("Liquid stack can't have conditions"); + } + + @Override + public IIngredient marked(String mark) + { + throw new UnsupportedOperationException("Liquid stack can't be marked"); + } + + @Override + public boolean matches(IItemStack item) + { + return false; + } + + @Override + public boolean matches(ILiquidStack liquid) + { + return getDefinition().equals(liquid.getDefinition()) + && getAmount() <= liquid.getAmount(); + } + + @Override + public boolean contains(IIngredient ingredient) + { + if (!ingredient.getItems().isEmpty()) + return false; + + for (ILiquidStack liquid : ingredient.getLiquids()) + { + if (!matches(liquid)) + return false; + } + + return false; + } + + @Override + public IItemStack applyTransform(IItemStack item, IPlayer byPlayer) + { + return item; + } + + @Override + public boolean hasTransformers() + { + return false; + } } diff --git a/MineTweaker3-MC172-Main/src/main/java/minetweaker/mc172/oredict/MCOreDictEntry.java b/MineTweaker3-MC172-Main/src/main/java/minetweaker/mc172/oredict/MCOreDictEntry.java index b10b7d4..2825531 100644 --- a/MineTweaker3-MC172-Main/src/main/java/minetweaker/mc172/oredict/MCOreDictEntry.java +++ b/MineTweaker3-MC172-Main/src/main/java/minetweaker/mc172/oredict/MCOreDictEntry.java @@ -7,6 +7,7 @@ package minetweaker.mc172.oredict; import java.util.ArrayList; +import java.util.Collections; import java.util.List; import minetweaker.IUndoableAction; import minetweaker.MineTweakerAPI; @@ -17,6 +18,7 @@ import minetweaker.api.item.IItemStack; import minetweaker.api.item.IItemTransformer; import minetweaker.api.item.IngredientOr; import minetweaker.api.item.IngredientStack; +import minetweaker.api.liquid.ILiquidStack; import static minetweaker.api.minecraft.MineTweakerMC.getIItemStackWildcardSize; import static minetweaker.api.minecraft.MineTweakerMC.getItemStack; import minetweaker.api.oredict.IOreDictEntry; @@ -128,6 +130,11 @@ public class MCOreDictEntry implements IOreDictEntry { } return result; } + + @Override + public List getLiquids() { + return Collections.emptyList(); + } @Override public IIngredient amount(int amount) { @@ -158,6 +165,11 @@ public class MCOreDictEntry implements IOreDictEntry { public boolean matches(IItemStack item) { return contains(item); } + + @Override + public boolean matches(ILiquidStack liquid) { + return false; + } @Override public boolean contains(IIngredient ingredient) { diff --git a/MineTweaker3-MC172-Main/src/main/java/minetweaker/mc172/recipes/MCRecipeManager.java b/MineTweaker3-MC172-Main/src/main/java/minetweaker/mc172/recipes/MCRecipeManager.java index 883f2ec..20b6070 100644 --- a/MineTweaker3-MC172-Main/src/main/java/minetweaker/mc172/recipes/MCRecipeManager.java +++ b/MineTweaker3-MC172-Main/src/main/java/minetweaker/mc172/recipes/MCRecipeManager.java @@ -326,7 +326,8 @@ public class MCRecipeManager implements IRecipeManager { @Override public void undo() { for (int i = 0; i < removingIndices.size(); i++) { - recipes.add(removingIndices.get(i), removingRecipes.get(i)); + int index = Math.min(recipes.size(), removingIndices.get(i)); + recipes.add(index, removingRecipes.get(i)); } } diff --git a/configuration.gradle b/configuration.gradle index acfc7f6..7b838db 100644 --- a/configuration.gradle +++ b/configuration.gradle @@ -2,7 +2,7 @@ // ### Global settings ### // ####################### -ext.mineTweakerVersion = "3.0.9B" +ext.mineTweakerVersion = "3.0.9C" ext.mineTweakerDebug = "false" ext.javaToolsJar = new File("C:/Program Files/Java/jdk1.8.0_05/lib/tools.jar") @@ -45,4 +45,5 @@ ext.projects1710 = [ 'MineTweaker3-MC1710-Mod-MFR', 'MineTweaker3-MC1710-Mod-GregTech', 'MineTweaker3-MC1710-Mod-Buildcraft' + //'MineTweaker3-MC1710-Mod-Buildcraft61' ]