upstream/JustEnoughCalculation
1
0 Fork 0
mirror of https://github.com/GTNewHorizons/JustEnoughCalculation.git synced 2026-11-14 01:04:06 +00:00
Code Issues Packages Projects Releases Wiki Activity

feat: add gregtech support, fix ore dictionary

Browse Source
This commit is contained in:
Discreater committed 2021-05-05 19:44:11 +08:00
1 parent 91f256eafa
commit e44678bc82
17 files changed
+301 -448
Download Patch File Download Diff File Expand all files Collapse all files

No files matched your search

src/main/java/me/towdium/jecalculation/data/Controller.java
+19 -40
View File
@@ -32,29 +32,16 @@ import java.util.stream.Stream;
@ParametersAreNonnullByDefault
@SideOnly(Side.CLIENT)
public class Controller {
public static final String KEY_RECIPES = "recipes";
public static final String KEY_MATH = "math";
public static final String KEY_CRAFT = "craft";
public static final String KEY_PLAYER = "player";
static RecordPlayer rPlayerServer;
static RecordPlayer rPlayerClient;
static RecordCraft rCraftClient;
static RecordMath rMathClient;
public static void setRecordsServer(RecordPlayer r) {
rPlayerServer = r;
}
public static boolean isServerActive() {
return rPlayerServer != null;
}
static Recipes getRecipes() {
if (isServerActive())
return rPlayerServer.recipes;
else
return rPlayerClient.recipes;
return rPlayerClient.recipes;
}
static Optional<ItemStack> getStack() {
@@ -72,7 +59,9 @@ public class Controller {
JustEnoughCalculation.logger.warn("File " + f.getAbsolutePath() + " contains invalid records.");
return nbt == null ? null : new Recipes(nbt);
};
return Arrays.stream(fs).map(i -> new Pair<>(i.getName(), read.apply(i))).filter(i -> i.two != null)
return Arrays.stream(fs)
.map(i -> new Pair<>(i.getName(), read.apply(i)))
.filter(i -> i.two != null)
.collect(Collectors.toList());
}
@@ -86,8 +75,8 @@ public class Controller {
private static void export(String s, Function<Recipes, NBTTagCompound> r) {
File f = JecaConfig.getDataFile(s);
Utilities.Json.write(r.apply(getRecipes()), f);
Minecraft.getMinecraft().thePlayer.addChatMessage(new ChatComponentTranslation(
"jecalculation.chat.export", f.getAbsolutePath()));
Minecraft.getMinecraft().thePlayer.addChatMessage(
new ChatComponentTranslation("jecalculation.chat.export", f.getAbsolutePath()));
}
public static void export(String group) {
@@ -100,12 +89,11 @@ public class Controller {
@Nullable
public static String getLast() {
return isServerActive() ? rPlayerServer.last : rPlayerClient.last;
return rPlayerClient.last;
}
static void setLast(String last) {
if (isServerActive()) rPlayerServer.last = last;
else rPlayerClient.last = last;
rPlayerClient.last = last;
}
public static List<String> getGroups() {
@@ -180,20 +168,11 @@ public class Controller {
}
private static <T extends IRecord> void setR(T t, Consumer<T> c, String s) {
if (!isServerActive()) c.accept(t);
else {
Optional<ItemStack> ois = getStack();
ois.ifPresent(is -> {
Utilities.getTag(is).setTag(s, t.serialize());
});
}
c.accept(t);
}
public static <T> T getR(T t, String s, Function<NBTTagCompound, T> f) {
if (!isServerActive()) return t;
else return f.apply(getStack()
.map(i -> Utilities.getTag(i).getCompoundTag(s))
.orElse(new NBTTagCompound()));
return t;
}
/**
@@ -207,8 +186,10 @@ public class Controller {
public static boolean hasDuplicate(Recipe r, String group, int index) {
Recipes.RecipeIterator ri = recipeIterator();
return ri.stream().anyMatch(i -> {
if (ri.getIndex() == index && ri.getGroup().equals(group)) return false;
else return i.equals(r);
if (ri.getIndex() == index && ri.getGroup().equals(group))
return false;
else
return i.equals(r);
});
}
@@ -227,7 +208,9 @@ public class Controller {
if (nbt != null) {
rCraftClient = new RecordCraft(nbt.getCompoundTag(KEY_CRAFT));
rMathClient = new RecordMath(nbt.getCompoundTag(KEY_MATH));
rPlayerClient = nbt.hasKey(KEY_PLAYER) ? new RecordPlayer(nbt.getCompoundTag(KEY_PLAYER)) : new RecordPlayer();
rPlayerClient = nbt.hasKey(KEY_PLAYER) ?
new RecordPlayer(nbt.getCompoundTag(KEY_PLAYER)) :
new RecordPlayer();
} else {
rPlayerClient = new RecordPlayer();
rCraftClient = new RecordCraft(new NBTTagCompound());
@@ -254,16 +237,12 @@ public class Controller {
}
public static void openGuiCraft(boolean scheduled) {
if (!Controller.isServerActive()) JecaGui.displayGui(true, true, scheduled, new GuiCraft());
else Minecraft.getMinecraft().thePlayer.addChatMessage(
new ChatComponentTranslation("jecalculation.chat.server_mode"));
JecaGui.displayGui(true, true, scheduled, new GuiCraft());
}
public static void openGuiMath(boolean scheduled) {
if (!Controller.isServerActive()) JecaGui.displayGui(true, true, scheduled, new GuiMath());
else Minecraft.getMinecraft().thePlayer.addChatMessage(
new ChatComponentTranslation("jecalculation.chat.server_mode"));
JecaGui.displayGui(true, true, scheduled, new GuiMath());
}
src/main/java/me/towdium/jecalculation/data/label/ILabel.java
-1
View File
@@ -277,7 +277,6 @@ public interface ILabel {
}
public Pair<List<ILabel>, List<ILabel>> guess(List<ILabel> labels, @Nullable IRecipeHandler context) {
List<ILabel> ret = new ArrayList<>();
List<ILabel> suggest = new ReversedIterator<>(handlers.get(Priority.SUGGEST)).stream().flatMap(
h -> h.convert(labels, context).stream()).collect(Collectors.toList());
List<ILabel> fallback = new ReversedIterator<>(handlers.get(Priority.FALLBACK)).stream().flatMap(
src/main/java/me/towdium/jecalculation/data/label/labels/LItemStack.java
+61 -62
View File
@@ -1,11 +1,13 @@
package me.towdium.jecalculation.data.label.labels;
import codechicken.nei.recipe.IRecipeHandler;
import cpw.mods.fml.common.registry.GameData;
import cpw.mods.fml.relauncher.Side;
import cpw.mods.fml.relauncher.SideOnly;
import me.towdium.jecalculation.data.label.ILabel;
import me.towdium.jecalculation.gui.JecaGui;
import me.towdium.jecalculation.gui.Resource;
import me.towdium.jecalculation.utils.ItemStackHelper;
import me.towdium.jecalculation.utils.Utilities;
import net.minecraft.item.Item;
import net.minecraft.item.ItemStack;
@@ -27,38 +29,40 @@ import static net.minecraftforge.oredict.OreDictionary.WILDCARD_VALUE;
@ParametersAreNonnullByDefault
public class LItemStack extends ILabel.Impl {
public static final String IDENTIFIER = "itemStack";
public static final String KEY_ITEM = "item";
public static final String KEY_META = "meta";
public static final String KEY_NBT = "nbt";
public static final String KEY_F_META = "fMeta";
public static final String KEY_F_CAP = "fCap";
public static final String KEY_F_NBT = "fNbt";
private static final String KEY_ITEM = "item";
private static final String KEY_META = "meta";
private static final String KEY_NBT = "tag"; // don't modify it
private static final String KEY_F_META = "fMeta";
private static final String KEY_F_NBT = "fNbt";
Item item;
int meta;
NBTTagCompound nbt;
boolean fMeta;
boolean fNbt;
boolean fCap;
transient ItemStack temp;
// Convert from itemStack
public LItemStack(ItemStack is) {
super(is.stackSize, false);
init(is.getItem(), is.getItemDamage(), is.getTagCompound(), false, false, false);
init(is.getItem(), is.getItemDamage(), is.getTagCompound(), false, false);
}
public LItemStack(NBTTagCompound tag) {
super(tag);
String id = tag.getString(KEY_ITEM);
Item i = Item.getItemById(tag.getInteger(KEY_ITEM));
if (i == null) throw new Serializer.SerializationException("Item " + id + " cannot be resolved, ignoring");
init(i, tag.getInteger(KEY_META),
tag.hasKey(KEY_NBT) ? tag.getCompoundTag(KEY_NBT) : null,
tag.getBoolean(KEY_F_META),
tag.getBoolean(KEY_F_CAP),
tag.getBoolean(KEY_F_NBT)
);
final String strId = tag.getString(KEY_ITEM);
if(!tag.hasKey("id"))
tag.setShort("id", (short) GameData.getItemRegistry().getId(strId));
tag.setByte("Count", (byte)1);
tag.setShort("Damage", tag.hasKey(KEY_META) ? (short)tag.getInteger(KEY_META) : 0);
ItemStack stack = ItemStack.loadItemStackFromNBT(tag);
if (ItemStackHelper.isEmpty(stack))
throw new Serializer.SerializationException("Item " + strId + " cannot be resolved, ignoring");
Item i = stack.getItem();
init(i, tag.getInteger(KEY_META), tag.hasKey(KEY_NBT) ? stack.stackTagCompound : null,
tag.getBoolean(KEY_F_META), tag.getBoolean(KEY_F_NBT));
}
private LItemStack(LItemStack lis) {
@@ -68,22 +72,15 @@ public class LItemStack extends ILabel.Impl {
nbt = lis.nbt;
fMeta = lis.fMeta;
fNbt = lis.fNbt;
fCap = lis.fCap;
temp = lis.temp;
}
private void init(@Nullable Item item,
int meta,
@Nullable NBTTagCompound nbt,
boolean fMeta,
boolean fCap,
boolean fNbt) {
private void init(@Nullable Item item, int meta, @Nullable NBTTagCompound nbt, boolean fMeta, boolean fNbt) {
Objects.requireNonNull(item);
this.item = item;
this.meta = fMeta ? 0 : meta;
this.nbt = fNbt ? null : nbt;
this.fMeta = fMeta;
this.fCap = fCap;
this.fNbt = fNbt;
temp = new ItemStack(item, 1, this.meta);
temp.setTagCompound(this.nbt);
@@ -94,12 +91,15 @@ public class LItemStack extends ILabel.Impl {
if (a instanceof LItemStack && b instanceof LItemStack) {
LItemStack lisA = (LItemStack) a;
LItemStack lisB = (LItemStack) b;
if (lisA.meta != lisB.meta && !lisA.fMeta && lisA.meta != WILDCARD_VALUE
&& !lisB.fMeta && lisB.meta != WILDCARD_VALUE) return false;
if (lisA.meta != lisB.meta && !lisA.fMeta && lisA.meta != WILDCARD_VALUE && !lisB.fMeta &&
lisB.meta != WILDCARD_VALUE)
return false;
if (!lisA.fNbt && !lisB.fNbt) {
if (lisA.nbt == null) {
if (lisB.nbt != null) return false;
} else if (lisB.nbt == null || !lisA.nbt.equals(lisB.nbt)) return false;
if (lisB.nbt != null)
return false;
} else if (lisB.nbt == null || !lisA.nbt.equals(lisB.nbt))
return false;
}
return lisA.item == lisB.item;
}
@@ -107,21 +107,27 @@ public class LItemStack extends ILabel.Impl {
}
public static List<ILabel> suggest(List<ILabel> iss, @Nullable IRecipeHandler rl) {
if (iss.size() == 0) return new ArrayList<>();
for (ILabel i : iss) if (!(i instanceof LItemStack)) return new ArrayList<>();
if (iss.size() == 0)
return new ArrayList<>();
for (ILabel i : iss)
if (!(i instanceof LItemStack))
return new ArrayList<>();
LItemStack lis = (LItemStack) iss.get(0);
boolean fMeta = false;
boolean fNbt = false;
boolean fCap = false;
for (ILabel i : iss) {
LItemStack ii = (LItemStack) i;
if (ii.item != lis.item) return new ArrayList<>();
if (ii.meta != lis.meta || ii.fMeta) fMeta = true;
if (!Objects.equals(ii.nbt, lis.nbt)) fNbt = true;
if (ii.item != lis.item)
return new ArrayList<>();
if (ii.meta != lis.meta || ii.fMeta)
fMeta = true;
if (!Objects.equals(ii.nbt, lis.nbt))
fNbt = true;
}
if (fMeta || fNbt || fCap) return Collections.singletonList(
lis.copy().setFCap(fCap).setFMeta(fMeta).setFNbt(fNbt));
else return new ArrayList<>();
if (fMeta || fNbt)
return Collections.singletonList(lis.copy().setFMeta(fMeta).setFNbt(fNbt));
else
return new ArrayList<>();
}
@@ -129,20 +135,22 @@ public class LItemStack extends ILabel.Impl {
List<ILabel> ret = new ArrayList<>();
if (iss.size() == 1) {
ILabel label = iss.get(0);
if (!(label instanceof LItemStack)) return ret;
if (!(label instanceof LItemStack))
return ret;
LItemStack lis = (LItemStack) label;
if (lis.fCap || lis.fNbt || lis.fMeta) return new ArrayList<>();
if (lis.fNbt || lis.fMeta)
return new ArrayList<>();
ret.add(lis.copy().setFMeta(true));
ret.add(lis.copy().setFNbt(true));
ret.add(lis.copy().setFCap(true));
ret.add(lis.copy().setFMeta(true).setFNbt(true).setFCap(true));
ret.add(lis.copy().setFMeta(true).setFNbt(true));
}
return ret;
}
public LItemStack setFMeta(boolean f) {
fMeta = f;
if (f) meta = 0;
if (f)
meta = 0;
temp = new ItemStack(item, 1, meta);
temp.setTagCompound(nbt);
return this;
@@ -150,14 +158,8 @@ public class LItemStack extends ILabel.Impl {
public LItemStack setFNbt(boolean f) {
fNbt = f;
if (f) nbt = null;
temp = new ItemStack(item, 1, meta);
temp.setTagCompound(nbt);
return this;
}
public LItemStack setFCap(boolean f) {
fCap = f;
if (f)
nbt = null;
temp = new ItemStack(item, 1, meta);
temp.setTagCompound(nbt);
return this;
@@ -171,9 +173,10 @@ public class LItemStack extends ILabel.Impl {
@SideOnly(Side.CLIENT)
public void getToolTip(List<String> existing, boolean detailed) {
super.getToolTip(existing, detailed);
if (fMeta) existing.add(FORMAT_GREY + Utilities.I18n.get("label.item_stack.fuzzy_meta"));
if (fNbt) existing.add(FORMAT_GREY + Utilities.I18n.get("label.item_stack.fuzzy_nbt"));
if (fCap) existing.add(FORMAT_GREY + Utilities.I18n.get("label.item_stack.fuzzy_cap"));
if (fMeta)
existing.add(FORMAT_GREY + Utilities.I18n.get("label.item_stack.fuzzy_meta"));
if (fNbt)
existing.add(FORMAT_GREY + Utilities.I18n.get("label.item_stack.fuzzy_nbt"));
existing.add(FORMAT_BLUE + FORMAT_ITALIC + Utilities.getModName(item));
}
@@ -198,7 +201,7 @@ public class LItemStack extends ILabel.Impl {
if (l instanceof LItemStack) {
LItemStack lis = (LItemStack) l;
return (Objects.equals(nbt, lis.nbt)) && meta == lis.meta && item == lis.item && fNbt == lis.fNbt &&
super.matches(l) && fCap == lis.fCap && fMeta == lis.fMeta;
super.matches(l) && fMeta == lis.fMeta;
} else
return false;
}
@@ -212,19 +215,17 @@ public class LItemStack extends ILabel.Impl {
public NBTTagCompound toNbt() {
if (item == null)
return ILabel.EMPTY.toNbt();
int id = Item.getIdFromItem(item);
String strId = Item.itemRegistry.getNameForObject(item);
NBTTagCompound ret = super.toNbt();
if (meta != 0)
ret.setInteger(KEY_META, meta);
ret.setInteger(KEY_ITEM, id);
ret.setString(KEY_ITEM, strId);
if (nbt != null)
ret.setTag(KEY_NBT, nbt);
if (fMeta)
ret.setBoolean(KEY_F_META, true);
if (fNbt)
ret.setBoolean(KEY_F_NBT, true);
if (fCap)
ret.setBoolean(KEY_F_CAP, true);
return ret;
}
@@ -232,10 +233,8 @@ public class LItemStack extends ILabel.Impl {
@SideOnly(Side.CLIENT)
public void drawLabel(JecaGui gui) {
gui.drawItemStack(0, 0, temp, false);
if (fCap || fNbt || fMeta)
if (fNbt || fMeta)
gui.drawResource(Resource.LBL_FRAME, 0, 0);
if (fCap)
gui.drawResource(Resource.LBL_FR_LL, 0, 0);
if (fNbt)
gui.drawResource(Resource.LBL_FR_UL, 0, 0);
if (fMeta)
src/main/java/me/towdium/jecalculation/data/label/labels/LOreDict.java
+39 -11
View File
@@ -23,7 +23,6 @@ import javax.annotation.ParametersAreNonnullByDefault;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.function.BiPredicate;
import java.util.stream.Collectors;
/**
@@ -70,9 +69,13 @@ public class LOreDict extends ILabel.Impl {
if (a instanceof LOreDict && b instanceof LItemStack) {
LOreDict lod = (LOreDict) a;
LItemStack lis = (LItemStack) b;
return lod.getAmount() * lis.getAmount() < 0 &&
OreDictionary.getOres(lod.name).stream().map(Converter::from)
.anyMatch(i -> LItemStack.merge(i, lis));
if (lod.getAmount() * lis.getAmount() < 0) {
for (ItemStack ore : OreDictionary.getOres(lod.name)) {
if (LItemStack.merge(Converter.from(ore), lis)) {
return true;
}
}
}
}
return false;
}
@@ -110,16 +113,41 @@ public class LOreDict extends ILabel.Impl {
return false;
Wrapper<Boolean> acceptable = new Wrapper<>(true);
BiPredicate<ILabel, ItemStack> match = (l, o) -> l instanceof LItemStack &&
OreDictionary.itemMatches(o, ((LItemStack) l).getRep(), false);
if (biDir)
ores.stream().filter(ore -> labels.stream().noneMatch(label -> match.test(label, ore))).findAny()
.ifPresent(i -> acceptable.value = false);
labels.stream().filter(label -> ores.stream().noneMatch(ore -> match.test(label, ore))).findAny()
.ifPresent(i -> acceptable.value = false);
if (biDir) {
for (ItemStack ore : ores) {
boolean noneMatch = true;
for (ILabel label : labels) {
if (checkMatch(label, ore)) {
noneMatch = false;
break;
}
}
if (noneMatch) {
acceptable.value = false;
break;
}
}
}
for (ILabel label : labels) {
boolean noneMatch = true;
for (ItemStack ore : ores) {
if (checkMatch(label, ore)) {
noneMatch = false;
break;
}
}
if (noneMatch) {
acceptable.value = false;
break;
}
}
return acceptable.value;
}
private static boolean checkMatch(ILabel l, ItemStack o) {
return l instanceof LItemStack && OreDictionary.itemMatches(o, ((LItemStack) l).getRep(), false);
}
@Override
@Nonnull
public ItemStack getRepresentation() {
src/main/java/me/towdium/jecalculation/gui/guis/pickers/PickerItemStack.java
+1 -9
View File
@@ -26,8 +26,6 @@ public class PickerItemStack extends IPicker.Impl implements IGui {
WButton bConfirm = new WButtonIcon(149, 7, 20, 20, BTN_YES, "item_stack.confirm").setListener(i -> callback.accept(label.getLabel()));
WButton bNbtN = new WButtonIcon(49, 7, 20, 20, BTN_NBT_N, "item_stack.nbt_normal").setListener(i -> setFNbt(true));
WButton bNbtF = new WButtonIcon(49, 7, 20, 20, BTN_NBT_F, "item_stack.nbt_fuzzy").setListener(i -> setFNbt(false));
WButton bCapN = new WButtonIcon(68, 7, 20, 20, BTN_CAP_N, "item_stack.capability_normal").setListener(i -> setFCap(true));
WButton bCapF = new WButtonIcon(68, 7, 20, 20, BTN_CAP_F, "item_stack.capability_fuzzy").setListener(i -> setFCap(false));
WButton bMetaN = new WButtonIcon(30, 7, 20, 20, BTN_META_N, "item_stack.meta_normal").setListener(i -> setFMeta(true));
WButton bMetaF = new WButtonIcon(30, 7, 20, 20, BTN_META_F, "item_stack.meta_fuzzy").setListener(i -> setFMeta(false));
ILabel raw = ILabel.EMPTY;
@@ -40,12 +38,10 @@ public class PickerItemStack extends IPicker.Impl implements IGui {
public void update(ILabel l) {
raw = l;
setFCap(false);
setFMeta(false);
setFNbt(false);
boolean b = l == ILabel.EMPTY;
bNbtN.setDisabled(b);
bCapN.setDisabled(b);
bMetaN.setDisabled(b);
bConfirm.setDisabled(b);
}
@@ -58,10 +54,6 @@ public class PickerItemStack extends IPicker.Impl implements IGui {
setF(b, bMetaN, bMetaF, () -> fMeta = b);
}
private void setFCap(boolean b) {
setF(b, bCapN, bCapF, () -> fCap = b);
}
private void setF(boolean b, WButton be, WButton bd, Runnable r) {
remove(be, bd);
if (b) add(bd);
@@ -69,7 +61,7 @@ public class PickerItemStack extends IPicker.Impl implements IGui {
r.run();
if (raw instanceof LItemStack) {
LItemStack lis = (LItemStack) raw;
label.setLabel(lis.copy().setFCap(fCap).setFMeta(fMeta).setFNbt(fNbt));
label.setLabel(lis.copy().setFMeta(fMeta).setFNbt(fNbt));
}
}
}
src/main/java/me/towdium/jecalculation/nei/Adapter.java
+10
View File
@@ -4,7 +4,9 @@ import codechicken.nei.PositionedStack;
import codechicken.nei.recipe.IRecipeHandler;
import cpw.mods.fml.common.Loader;
import me.towdium.jecalculation.JustEnoughCalculation;
import me.towdium.jecalculation.nei.adapter.AE2;
import me.towdium.jecalculation.nei.adapter.Forestry;
import me.towdium.jecalculation.nei.adapter.GregTech;
import me.towdium.jecalculation.nei.adapter.IAdapter;
import java.util.ArrayList;
@@ -18,6 +20,14 @@ public class Adapter {
JustEnoughCalculation.logger.info("Forestry is installed");
adapters.add(new Forestry());
}
if (Loader.isModLoaded("appliedenergistics2")) {
JustEnoughCalculation.logger.info("ae2 installed");
adapters.add(new AE2());
}
if( Loader.isModLoaded("gregtech")) {
JustEnoughCalculation.logger.info("gregtech installed");
adapters.add(new GregTech());
}
}
public static void handleRecipe(IRecipeHandler recipe, int index, List<Object[]> inputs, List<Object[]> outputs) {
src/main/java/me/towdium/jecalculation/nei/NEICalculatorConfig.java
+18 -10
View File
@@ -4,23 +4,31 @@ import codechicken.nei.api.API;
import codechicken.nei.api.IConfigureNEI;
import me.towdium.jecalculation.JustEnoughCalculation;
import me.towdium.jecalculation.gui.JecaGui;
import me.towdium.jecalculation.nei.adapter.IAdapter;
import java.util.Arrays;
import java.util.Collection;
import java.util.HashSet;
import java.util.Set;
import java.util.stream.Collectors;
import java.util.stream.Stream;
public class NEICalculatorConfig implements IConfigureNEI {
@Override
public void loadConfig() {
String[] baseOverlayIdentifiers = new String[]{"crafting", "crafting2x2", "smelting", "fuel", "brewing"};
String[] ae2OverlayIdentifiers = new String[]{"inscriber", "grindstone"};
/* For the recipeHandlers which extend `TemplateRecipeHandler` without override the `getOverlayIdentifier` function */
String[] nullOverlayIdentifiers = new String[]{null};
Stream.of(baseOverlayIdentifiers, ae2OverlayIdentifiers, nullOverlayIdentifiers)
.flatMap(Stream::of)
.forEach(ident -> {
API.registerGuiOverlay(JecaGui.class, ident);
API.registerGuiOverlayHandler(JecaGui.class, new JecaOverlayHandler(), ident);
});
/* null For the recipeHandlers which extend `TemplateRecipeHandler` without override the `getOverlayIdentifier` function */
Set<String> baseOverlayIdentifiers = new HashSet<>(
Arrays.asList("crafting", "crafting2x2", "smelting", "fuel", "brewing", null));
Set<String> adapterIdentifiers = Adapter.adapters.stream()
.map(IAdapter::getAllOverlayIdentifier)
.flatMap(Collection::stream)
.collect(Collectors.toSet());
Stream.concat(baseOverlayIdentifiers.stream(), adapterIdentifiers.stream()).forEach(ident -> {
API.registerGuiOverlay(JecaGui.class, ident);
API.registerGuiOverlayHandler(JecaGui.class, new JecaOverlayHandler(), ident);
});
}
@Override
src/main/java/me/towdium/jecalculation/nei/adapter/AE2.java
+20
View File
@@ -0,0 +1,20 @@
package me.towdium.jecalculation.nei.adapter;
import codechicken.nei.recipe.IRecipeHandler;
import java.util.Arrays;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
public class AE2 implements IAdapter{
@Override
public Set<String> getAllOverlayIdentifier() {
return new HashSet<>(Arrays.asList("inscriber", "grindstone"));
}
@Override
public void handleRecipe(IRecipeHandler recipe, int index, List<Object[]> inputs, List<Object[]> outputs) {
}
}
src/main/java/me/towdium/jecalculation/nei/adapter/Forestry.java
+12 -14
View File
@@ -34,7 +34,7 @@ public class Forestry implements IAdapter {
private void bottler(RecipeHandlerBase recipe, int recipeIndex, List<Object[]> inputs) {
if (recipe instanceof NEIHandlerBottler) {
List<List<FluidStack>> fluids = getFluids(recipe, recipeIndex);
if(fluids.size() >= 1)
if (fluids.size() >= 1)
inputs.add(fluids.get(0).toArray());
}
}
@@ -42,7 +42,7 @@ public class Forestry implements IAdapter {
private void carpenter(RecipeHandlerBase recipe, int recipeIndex, List<Object[]> inputs) {
if (recipe instanceof NEIHandlerCarpenter) {
List<List<FluidStack>> fluids = getFluids(recipe, recipeIndex);
if(fluids.size() >= 1)
if (fluids.size() >= 1)
inputs.add(fluids.get(0).toArray());
}
}
@@ -50,22 +50,20 @@ public class Forestry implements IAdapter {
private void centrifuge(RecipeHandlerBase recipe, int recipeIndex, List<Object[]> outputs) {
if (recipe instanceof NEIHandlerCentrifuge) {
List<PositionedStack> otherStacks = recipe.getOtherStacks(recipeIndex);
otherStacks.stream()
.map(positionedStack -> positionedStack.items)
.forEach(outputs::add);
otherStacks.stream().map(positionedStack -> positionedStack.items).forEach(outputs::add);
}
}
private void fabricator(RecipeHandlerBase recipe, int recipeIndex, List<Object[]> inputs) {
if (recipe instanceof NEIHandlerFabricator) {
List<List<FluidStack>> fluids = getFluids(recipe, recipeIndex);
if(fluids.size() >= 1)
if (fluids.size() >= 1)
inputs.add(fluids.get(0).toArray());
}
}
private void fermenter(RecipeHandlerBase recipe, int recipeIndex, List<Object[]> inputs, List<Object[]> outputs) {
if(recipe instanceof NEIHandlerFermenter) {
if (recipe instanceof NEIHandlerFermenter) {
List<PositionedFluidTank> tanks = getTanks(recipe, recipeIndex);
tanks.forEach(tank -> {
Object[] fluids = Arrays.stream(tank.tanks).map(FluidTank::getFluid).toArray();
@@ -81,14 +79,14 @@ public class Forestry implements IAdapter {
}
private void moistener(RecipeHandlerBase recipe, int recipeIndex, List<Object[]> inputs, List<Object[]> outputs) {
if(recipe instanceof NEIHandlerMoistener) {
if (recipe instanceof NEIHandlerMoistener) {
List<List<FluidStack>> fluids = getFluids(recipe, recipeIndex);
if(fluids.size() >= 1)
if (fluids.size() >= 1)
inputs.add(fluids.get(0).toArray());
List<PositionedStack> otherStacks = recipe.getOtherStacks(recipeIndex);
otherStacks.forEach(positionedStack -> {
ItemStack[] items = positionedStack.items;
if(positionedStack.relx == 34) {
if (positionedStack.relx == 34) {
// item
inputs.add(items);
} else {
@@ -100,18 +98,18 @@ public class Forestry implements IAdapter {
}
private void squeezer(RecipeHandlerBase recipe, int recipeIndex, List<Object[]> inputs, List<Object[]> outputs) {
if(recipe instanceof NEIHandlerSqueezer) {
if (recipe instanceof NEIHandlerSqueezer) {
List<List<FluidStack>> fluids = getFluids(recipe, recipeIndex);
if(fluids.size() >= 1)
if (fluids.size() >= 1)
outputs.add(fluids.get(0).toArray());
}
}
private void still(RecipeHandlerBase recipe, int recipeIndex, List<Object[]> inputs, List<Object[]> outputs) {
if(recipe instanceof NEIHandlerStill) {
if (recipe instanceof NEIHandlerStill) {
getTanks(recipe, recipeIndex).forEach(tank -> {
Object[] fluids = Arrays.stream(tank.tanks).map(FluidTank::getFluid).toArray();
if(tank.position.x == 30) {
if (tank.position.x == 30) {
// input
inputs.add(fluids);
} else {
src/main/java/me/towdium/jecalculation/nei/adapter/GregTech.java
+85
View File
@@ -0,0 +1,85 @@
package me.towdium.jecalculation.nei.adapter;
import codechicken.nei.NEIServerUtils;
import codechicken.nei.PositionedStack;
import codechicken.nei.recipe.IRecipeHandler;
import gregtech.api.util.GT_Recipe;
import gregtech.api.util.GT_Utility;
import gregtech.nei.GT_NEI_AssLineHandler;
import gregtech.nei.GT_NEI_DefaultHandler;
import net.minecraft.item.ItemStack;
import net.minecraftforge.fluids.FluidStack;
import javax.annotation.ParametersAreNonnullByDefault;
import java.util.Arrays;
import java.util.List;
import java.util.Set;
import java.util.stream.Collectors;
@ParametersAreNonnullByDefault
public class GregTech implements IAdapter {
@Override
public Set<String> getAllOverlayIdentifier() {
return GT_Recipe.GT_Recipe_Map.sMappings.stream()
.map(gt_recipe_map -> gt_recipe_map.mNEIName)
.collect(Collectors.toSet());
}
@Override
public void handleRecipe(IRecipeHandler recipe, int index, List<Object[]> inputs, List<Object[]> outputs) {
if (recipe instanceof GT_NEI_DefaultHandler || recipe instanceof GT_NEI_AssLineHandler) {
for (int i = 0; i < inputs.size(); i++) {
Object[] objects = Arrays.stream(inputs.get(i)).map(o -> this.convertFluid((ItemStack) o)).toArray();
inputs.set(i, objects);
}
List<PositionedStack> otherStacks = recipe.getOtherStacks(index);
outputs.addAll(otherStacks.stream()
.map(positionedStack -> positionedStack.items)
.map(itemStacks -> Arrays.stream(itemStacks).map(this::convertFluid).toArray())
.collect(Collectors.toList()));
}
}
private Object convertFluid(ItemStack itemStack) {
FluidStack fluidStack = GT_Utility.getFluidFromDisplayStack(itemStack);
return fluidStack == null ? itemStack : fluidStack;
}
/**
* get from `gregtech.nei.GT_NEI_AssLineHandler$CachedDefaultRecipe::Constructor`
*
* @param recipe GT_Recipe
* @param inputs input list
* @param outputs output list
*/
@Deprecated
private void getFromRecipe(GT_Recipe recipe, List<Object[]> inputs, List<Object[]> outputs) {
for (int i = 0; i < recipe.mInputs.length; i++) {
Object obj = recipe instanceof GT_Recipe.GT_Recipe_WithAlt ?
((GT_Recipe.GT_Recipe_WithAlt) recipe).getAltRepresentativeInput(i) :
recipe.getRepresentativeInput(i);
if (obj != null) {
inputs.add(NEIServerUtils.extractRecipeItems(obj));
}
}
if (recipe.mSpecialItems != null) {
inputs.add(NEIServerUtils.extractRecipeItems(recipe.mSpecialItems));
}
if (recipe.getOutput(0) != null) {
outputs.add(NEIServerUtils.extractRecipeItems(recipe.getOutput(0)));
}
for (FluidStack mFluidInput : recipe.mFluidInputs) {
if (mFluidInput != null && mFluidInput.getFluid() != null) {
inputs.add(new Object[]{mFluidInput});
}
}
for (FluidStack mFluidOutput : recipe.mFluidOutputs) {
if (mFluidOutput != null && mFluidOutput.getFluid() != null) {
outputs.add(new Object[]{mFluidOutput});
}
}
}
}
src/main/java/me/towdium/jecalculation/nei/adapter/IAdapter.java
+6
View File
@@ -3,9 +3,15 @@ package me.towdium.jecalculation.nei.adapter;
import codechicken.nei.recipe.IRecipeHandler;
import javax.annotation.ParametersAreNonnullByDefault;
import java.util.Collections;
import java.util.List;
import java.util.Set;
@ParametersAreNonnullByDefault
public interface IAdapter {
default Set<String> getAllOverlayIdentifier() {
return Collections.emptySet();
};
void handleRecipe(IRecipeHandler recipe, int index, List<Object[]> inputs, List<Object[]> outputs);
}
src/main/java/me/towdium/jecalculation/polyfill/NBTHelper.java
+8
View File
@@ -8,10 +8,12 @@ import net.minecraft.nbt.NBTBase;
import net.minecraft.nbt.NBTTagCompound;
import net.minecraft.nbt.NBTTagList;
import javax.annotation.ParametersAreNonnullByDefault;
import java.util.List;
import java.util.Spliterator;
import java.util.Spliterators;
@ParametersAreNonnullByDefault
public class NBTHelper {
/**
* Get an NBTTagCompound from this stack's NBT data.
@@ -48,4 +50,10 @@ public class NBTHelper {
}
}
public static NBTTagCompound serializeNBT(ItemStack stack) {
NBTTagCompound ret = new NBTTagCompound();
stack.writeToNBT(ret);
return ret;
}
}
src/main/java/me/towdium/jecalculation/utils/ItemStackHelper.java
-298
View File
@@ -12,309 +12,11 @@ import java.util.function.Consumer;
import java.util.function.Function;
public class ItemStackHelper {
public static final String keyAmount = "amount";
public static final String keyType = "type";
public static final Item EMPTY_ITEM = null;
public static final ItemStack EMPTY_ITEM_STACK = new ItemStack((Item)null);
public enum EnumStackAmountType {
INVALID, NUMBER, PERCENTAGE, FLUID;
public String getDisplayString(long l) {
switch (this) {
case NUMBER:
if (l < 999) {
return String.valueOf(l);
} else if (l < 9999) {
return String.format("%.2fK", (double) l / 1000);
} else if (l < 99999) {
return String.format("%.1fK", (double) l / 1000);
} else if (l < 999999) {
return String.format("%.0fK", (double) l / 1000);
} else if (l < 9999999) {
return String.format("%.2fM", (double) l / 1000000);
} else if (l < 99999999) {
return String.format("%.1fM", (double) l / 1000000);
} else if (l < 999999999) {
return String.format("%.0fB", (double) l / 1000000);
} else if (l < 9999999999L) {
return String.format("%.2fB", (double) l / 1000000000);
} else if (l < 99999999999L) {
return String.format("%.1fB", (double) l / 1000000000);
} else if (l < 999999999999L) {
return String.format("%.0fT", (double) l / 1000000000);
} else if (l < 9999999999999L) {
return String.format("%.2fT", (double) l / 1000000000000L);
} else if (l < 99999999999999L) {
return String.format("%.1fT", (double) l / 1000000000000L);
} else if (l < 999999999999999L) {
return String.format("%.0fG", (double) l / 1000000000000L);
} else if (l < 9999999999999999L) {
return String.format("%.2fG", (double) l / 1000000000000000L);
} else if (l < 99999999999990999L) {
return String.format("%.1fG", (double) l / 1000000000000000L);
} else {
return String.format("%.0fG", (double) l / 1000000000000000L);
}
case PERCENTAGE:
if (l < 999) {
return String.valueOf(l);
} else if (l < 9999) {
return String.format("≈%.1fK", (double) l / 1000);
} else if (l < 99999) {
return String.format("≈%.0fK", (double) l / 1000);
} else if (l < 999999) {
return String.format("≈%.1fM", (double) l / 1000000);
} else if (l < 9999999) {
return String.format("≈%.1fM", (double) l / 1000000);
} else if (l < 99999999) {
return String.format("≈%.0fM", (double) l / 1000000);
} else if (l < 999999999) {
return String.format("≈%.1fB", (double) l / 1000000000);
} else if (l < 9999999999L) {
return String.format("≈%.1fB", (double) l / 1000000000);
} else if (l < 99999999999L) {
return String.format("≈%.0fB", (double) l / 1000000000);
} else if (l < 999999999999L) {
return String.format("≈%.1fT", (double) l / 1000000000000L);
} else if (l < 9999999999999L) {
return String.format("≈%.1fT", (double) l / 1000000000000L);
} else if (l < 99999999999999L) {
return String.format("≈%.0fT", (double) l / 1000000000000L);
} else if (l < 999999999999999L) {
return String.format("≈%.1fG", (double) l / 1000000000000000L);
} else if (l < 9999999999999999L) {
return String.format("≈%.1fG", (double) l / 1000000000000000L);
} else {
return String.format("≈%.0fG", (double) l / 1000000000000000L);
}
case FLUID:
if (l < 999) {
return l + "mb";
} else if (l < 9999) {
return String.format("%.2fb", (double) l / 1000);
} else if (l < 99999) {
return String.format("%.1fb", (double) l / 1000);
} else if (l < 999999) {
return String.format("%.0fb", (double) l / 1000);
} else if (l < 9999999) {
return String.format("%.1fKb", (double) l / 1000000);
} else if (l < 99999999) {
return String.format("%.0fKb", (double) l / 1000000);
} else if (l < 999999999) {
return String.format("%.1fMb", (double) l / 1000000000);
} else if (l < 9999999999L) {
return String.format("%.1fMb", (double) l / 1000000000);
} else if (l < 99999999999L) {
return String.format("%.0fMb", (double) l / 1000000000);
} else if (l < 999999999999L) {
return String.format("%.1fBb", (double) l / 1000000000000L);
} else if (l < 9999999999999L) {
return String.format("%.1fBb", (double) l / 1000000000000L);
} else if (l < 99999999999999L) {
return String.format("%.0fBb", (double) l / 1000000000000L);
} else if (l < 999999999999999L) {
return String.format("%.1fTb", (double) l / 1000000000000000L);
} else if (l < 9999999999999999L) {
return String.format("%.1fTb", (double) l / 1000000000000000L);
} else {
return String.format("%.0fTb", (double) l / 1000000000000000L);
}
default:
return "N/A";
}
}
}
public static boolean isEmpty(ItemStack stack) {
return stack == null || stack == EMPTY_ITEM_STACK || stack.getItem() == EMPTY_ITEM;
}
public static boolean isTypeEqual(@Nullable ItemStack one, @Nullable ItemStack two) {
return one != null && two != null && one.getItem() == two.getItem() && getMetadata(one) == getMetadata(two) &&
NBT.equalsIgnoreJEC(one.getTagCompound(), two.getTagCompound());
}
@Nullable
public static ItemStack toItemStackJEC(ItemStack itemStack) {
if (itemStack == null)
return null;
NBT.setData(itemStack, EnumStackAmountType.NUMBER, itemStack.stackSize);
itemStack.stackSize = 1;
return itemStack;
}
public static boolean isItemStackJEC(@Nullable ItemStack itemStack) {
return itemStack != null && itemStack.getTagCompound() != null &&
itemStack.getTagCompound().hasKey(JustEnoughCalculation.Reference.MODID);
}
private static int getMetadata(ItemStack stack) {
return stack.getItemDamage();
}
public static class NBT {
public static boolean equalsIgnoreJEC(@Nullable NBTTagCompound a, @Nullable NBTTagCompound b) {
if (a == null && b == null) {
return true;
} else if (a == null || b == null) {
return false;
} else {
NBTTagCompound aNew = ((NBTTagCompound) a.copy());
aNew.removeTag(JustEnoughCalculation.Reference.MODID);
NBTTagCompound bNew = ((NBTTagCompound) b.copy());
bNew.removeTag(JustEnoughCalculation.Reference.MODID);
return aNew.equals(bNew);
}
}
public static ItemStack setAmount(ItemStack itemStack, long amount) {
return setLong(itemStack, true, keyAmount, amount);
}
public static ItemStack setType(ItemStack itemStack, EnumStackAmountType type) {
return setInteger(itemStack, true, keyType, type.ordinal());
}
public static ItemStack setData(ItemStack itemStack, EnumStackAmountType type, long amount) {
setInteger(itemStack, true, keyType, type.ordinal());
return setLong(itemStack, true, keyAmount, amount);
}
public static ItemStack setInteger(ItemStack itemStack, boolean isolate, String key, int value) {
return setValue(itemStack, isolate, (nbtTagCompound -> nbtTagCompound.setInteger(key, value)));
}
public static ItemStack setLong(ItemStack itemStack, boolean isolate, String key, long value) {
return setValue(itemStack, isolate, (nbtTagCompound -> nbtTagCompound.setLong(key, value)));
}
public static ItemStack setBoolean(ItemStack itemStack, boolean isolate, String key, boolean value) {
return setValue(itemStack, isolate, (nbtTagCompound -> nbtTagCompound.setBoolean(key, value)));
}
static ItemStack setValue(ItemStack itemStack, boolean isolate, Consumer<NBTTagCompound> func) {
NBTTagCompound tagCompound = itemStack.getTagCompound();
if (tagCompound == null) {
tagCompound = new NBTTagCompound();
itemStack.setTagCompound(tagCompound);
}
if (isolate) {
if (!tagCompound.hasKey(JustEnoughCalculation.Reference.MODID)) {
tagCompound.setTag(JustEnoughCalculation.Reference.MODID, new NBTTagCompound());
}
tagCompound = tagCompound.getCompoundTag(JustEnoughCalculation.Reference.MODID);
}
func.accept(tagCompound);
return itemStack;
}
public static EnumStackAmountType getType(ItemStack itemStack) {
return EnumStackAmountType.values()[getInteger(itemStack, true, keyType)];
}
public static long getAmount(ItemStack itemStack) {
return getLong(itemStack, true, keyAmount);
}
public static long getAmountItem(ItemStack itemStack) {
long amount = getAmount(itemStack);
switch (getType(itemStack)) {
case NUMBER:
return amount;
case PERCENTAGE:
return (amount + 99) % 100;
case FLUID:
return (amount + 999) % 1000;
default:
return 0;
}
}
public static long getAmountInternal(ItemStack itemStack) {
long amount = getAmount(itemStack);
switch (getType(itemStack)) {
case NUMBER:
return amount * 100;
case PERCENTAGE:
return amount;
case FLUID:
return amount;
default:
return 0;
}
}
public static int getInteger(ItemStack itemStack, boolean isolate, String key) {
return getTag(itemStack, isolate).getInteger(key);
}
public static long getLong(ItemStack itemStack, boolean isolate, String key) {
return getTag(itemStack, isolate).getLong(key);
}
static NBTTagCompound getTag(@Nonnull ItemStack itemStack, boolean isolate) {
if (isolate) {
return NBTHelper.getSubCompound(itemStack, JustEnoughCalculation.Reference.MODID, true);
} else {
if (!itemStack.hasTagCompound()) {
itemStack.setTagCompound(new NBTTagCompound());
}
return itemStack.getTagCompound();
}
}
}
public static class Click {
@Nullable
public static ItemStack leftClick(@Nullable ItemStack itemStack) {
return getClick(itemStack, (l -> l + 1), (l -> l + 1), (l -> 0L));
}
@Nullable
public static ItemStack leftShift(@Nullable ItemStack itemStack) {
return getClick(itemStack, (l -> l == 1 ? 10 : l + 10), (l -> l == 1 ? 10 : l + 10), (l -> 0L));
}
@Nullable
public static ItemStack rightClick(@Nullable ItemStack itemStack) {
return getClick(itemStack, (l -> l - 1), (l -> l - 1), (l -> 0L));
}
@Nullable
public static ItemStack rightShift(@Nullable ItemStack itemStack) {
return getClick(itemStack, (l -> l == 1 ? 0 : l <= 10 ? 1 : l - 10),
(l -> l == 1 ? 0 : l <= 10 ? 1 : l - 10), (l -> 0L));
}
@Nullable
static ItemStack getClick(@Nullable ItemStack itemStack,
Function<Long, Long> funcNumber,
Function<Long, Long> funcPercentage,
Function<Long, Long> funcFluid) {
if (itemStack == null) {
return null;
} else {
long amount = NBT.getAmount(itemStack);
switch (NBT.getType(itemStack)) {
case INVALID:
amount = 0;
break;
case NUMBER:
amount = funcNumber.apply(amount);
break;
case PERCENTAGE:
amount = funcPercentage.apply(amount);
break;
case FLUID:
amount = funcFluid.apply(amount);
break;
}
return amount == 0 ? null : NBT.setAmount(itemStack, amount);
}
}
}
}
src/main/java/me/towdium/jecalculation/utils/Utilities.java
+3
View File
@@ -20,6 +20,7 @@ import net.minecraft.nbt.NBTTagCompound;
import net.minecraft.nbt.NBTTagList;
import net.minecraft.util.IIcon;
import net.minecraftforge.fluids.Fluid;
import net.minecraftforge.fluids.FluidStack;
import org.apache.commons.io.FileUtils;
import org.apache.commons.lang3.StringEscapeUtils;
import org.apache.commons.lang3.text.WordUtils;
@@ -127,6 +128,8 @@ public class Utilities {
}
}
private static IIcon getFluidIcon(Fluid fluid) {
IIcon icon = fluid.getFlowingIcon();
if(icon == null) {