Merge pull request #923 from Nxer/OreDict

Extreme Crafting Center Rework : Perfectly compatible with Ore Dict system

Author: Nxer

src/main/java/com/Nxer/TwistSpaceTechnology/common/api/AlternativeItem.java

@@ -0,0 +1,77 @@
+package com.Nxer.TwistSpaceTechnology.common.api;
+
+import java.util.HashSet;
+import java.util.Objects;
+import java.util.Set;
+
+import net.minecraft.item.ItemStack;
+
+import org.jetbrains.annotations.NotNull;
+
+import com.Nxer.TwistSpaceTechnology.util.rewrites.TST_ItemID;
+
+public class AlternativeItem implements IAlternativeItem {
+
+    public final String name;
+    private final Set<TST_ItemID> containedItems = new HashSet<>();
+
+    public AlternativeItem(@NotNull String name, ItemStack... itemStacks) {
+        this.name = name;
+        for (ItemStack itemStack : itemStacks) {
+            if (itemStack == null) continue;
+            containedItems.add(TST_ItemID.create(itemStack));
+        }
+    }
+
+    @Override
+    public boolean containsItem(TST_ItemID itemID) {
+        return containedItems.contains(itemID);
+    }
+
+    @Override
+    public boolean hasSameMember(IAlternativeItem another) {
+        for (TST_ItemID itemID : containedItems) {
+            if (another.containsItem(itemID)) return true;
+        }
+        return false;
+    }
+
+    @Override
+    public @NotNull String getName() {
+        return name;
+    }
+
+    /**
+     * Add a new member to containing list. It would be better not to use this method because it will break consistency.
+     * 
+     * @return True if adding is success.
+     */
+    public boolean addMember(TST_ItemID itemID) {
+        return containedItems.add(itemID);
+    }
+
+    /**
+     * Add a new member to containing list. It would be better not to use this method because it will break consistency.
+     * 
+     * @return True if adding is success.
+     */
+    public boolean addMember(ItemStack itemStack) {
+        return addMember(TST_ItemID.create(itemStack));
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) {
+            return true;
+        }
+        if (!(o instanceof AlternativeItem that)) {
+            return false;
+        }
+        return Objects.equals(getName(), that.getName()) && Objects.equals(containedItems, that.containedItems);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(getName(), containedItems);
+    }
+}

src/main/java/com/Nxer/TwistSpaceTechnology/common/api/AlternativeItemStack.java

@@ -0,0 +1,25 @@
+package com.Nxer.TwistSpaceTechnology.common.api;
+
+public class AlternativeItemStack {
+
+    public final IAlternativeItem alternativeItem;
+    public int stackSize;
+
+    public AlternativeItemStack(IAlternativeItem alternativeItem, int stackSize) {
+        this.alternativeItem = alternativeItem;
+        this.stackSize = stackSize;
+    }
+
+    public boolean stackEqual(AlternativeItemStack another) {
+        return alternativeItem.equals(another.alternativeItem) && stackSize == another.stackSize;
+    }
+
+    public boolean isSameAlternativeItem(AlternativeItemStack another) {
+        return alternativeItem.equals(another.alternativeItem);
+    }
+
+    public AlternativeItemStack setStackSize(int stackSize) {
+        this.stackSize = stackSize;
+        return this;
+    }
+}

src/main/java/com/Nxer/TwistSpaceTechnology/common/api/IAlternativeItem.java

@@ -0,0 +1,59 @@
+package com.Nxer.TwistSpaceTechnology.common.api;
+
+import java.util.Collection;
+
+import net.minecraft.item.ItemStack;
+
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import com.Nxer.TwistSpaceTechnology.util.rewrites.TST_ItemID;
+
+/**
+ * To conveniently check an alternative items list we can make them a special Object to process.
+ * 
+ * @author Nxer
+ */
+public interface IAlternativeItem {
+
+    /**
+     * @return True if the item stack is a member of this item list.
+     */
+    default boolean containsItem(ItemStack itemStack) {
+        return containsItem(TST_ItemID.create(itemStack)) || containsItem(TST_ItemID.createAsWildcard(itemStack));
+    }
+
+    boolean containsItem(TST_ItemID itemID);
+
+    /**
+     * @return True if two lists has same member in it.
+     */
+    boolean hasSameMember(IAlternativeItem another);
+
+    /**
+     * @return The name of this item list.
+     */
+    @NotNull
+    String getName();
+
+    static @Nullable IAlternativeItem checkAlternativeItemContaining(Collection<IAlternativeItem> alternativeItems,
+        TST_ItemID itemID) {
+        for (IAlternativeItem alternativeItem : alternativeItems) {
+            if (alternativeItem.containsItem(itemID)) return alternativeItem;
+        }
+        return null;
+    }
+
+    static @Nullable IAlternativeItem checkAlternativeItemContaining(Collection<IAlternativeItem> alternativeItems,
+        ItemStack itemStack) {
+        for (IAlternativeItem alternativeItem : alternativeItems) {
+            if (alternativeItem.containsItem(itemStack)) return alternativeItem;
+        }
+        return null;
+    }
+
+    static @Nullable IAlternativeItem checkAlternativeItemContainingFast(Collection<IAlternativeItem> alternativeItems,
+        ItemStack itemStack) {
+        return checkAlternativeItemContaining(alternativeItems, TST_ItemID.create(itemStack));
+    }
+}

src/main/java/com/Nxer/TwistSpaceTechnology/common/api/OreDictItem.java

@@ -0,0 +1,79 @@
+package com.Nxer.TwistSpaceTechnology.common.api;
+
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Objects;
+import java.util.Set;
+
+import net.minecraft.item.ItemStack;
+import net.minecraftforge.oredict.OreDictionary;
+
+import org.jetbrains.annotations.NotNull;
+
+import com.Nxer.TwistSpaceTechnology.util.rewrites.TST_ItemID;
+
+public class OreDictItem implements IAlternativeItem {
+
+    public static final Map<String, OreDictItem> UsedOreDictItems = new HashMap<>();
+
+    public static OreDictItem getOreDictItems(String oreDictName) {
+        if (UsedOreDictItems.containsKey(oreDictName)) return UsedOreDictItems.get(oreDictName);
+
+        OreDictItem o = new OreDictItem(oreDictName);
+        UsedOreDictItems.put(oreDictName, o);
+        return o;
+    }
+
+    public final String oreDictName;
+    private final Set<TST_ItemID> containedItems = new HashSet<>();
+
+    public OreDictItem(@NotNull String oreDictName) {
+        this.oreDictName = oreDictName;
+        for (ItemStack itemStack : OreDictionary.getOres(oreDictName)) {
+            if (itemStack == null) continue;
+            containedItems.add(TST_ItemID.createNoNBT(itemStack));
+        }
+
+    }
+
+    @Override
+    public boolean containsItem(ItemStack itemStack) {
+        return containedItems.contains(TST_ItemID.createNoNBT(itemStack))
+            || containedItems.contains(TST_ItemID.createAsWildcard(itemStack));
+    }
+
+    @Override
+    public @NotNull String getName() {
+        return oreDictName;
+    }
+
+    public boolean containsItem(TST_ItemID itemID) {
+        return containedItems.contains(itemID);
+    }
+
+    @Override
+    public boolean hasSameMember(IAlternativeItem another) {
+        for (TST_ItemID itemID : containedItems) {
+            if (another.containsItem(itemID)) return true;
+        }
+        return false;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) {
+            return true;
+        }
+        if (!(o instanceof OreDictItem that)) {
+            return false;
+        }
+        return Objects.equals(oreDictName, that.oreDictName);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(oreDictName);
+    }
+
+}