diff options
Diffstat (limited to 'src')
10 files changed, 677 insertions, 104 deletions
diff --git a/src/Java/gtPlusPlus/core/util/math/MathUtils.java b/src/Java/gtPlusPlus/core/util/math/MathUtils.java index 4ba9d54271..3cef3c511f 100644 --- a/src/Java/gtPlusPlus/core/util/math/MathUtils.java +++ b/src/Java/gtPlusPlus/core/util/math/MathUtils.java @@ -692,8 +692,8 @@ public class MathUtils { return Math.max(Math.min(aInput, aMax), aMin); } - public static int getValueWithinRange(byte aInput, int aMin, int aMax) { - int aAmount = Math.max(Math.min(aInput, aMax), aMin); + public static int getValueWithinRange(int i, int aMin, int aMax) { + int aAmount = Math.max(Math.min(i, aMax), aMin); return aAmount; } diff --git a/src/Java/gtPlusPlus/core/util/minecraft/EnergyUtils.java b/src/Java/gtPlusPlus/core/util/minecraft/EnergyUtils.java new file mode 100644 index 0000000000..51bedaf64b --- /dev/null +++ b/src/Java/gtPlusPlus/core/util/minecraft/EnergyUtils.java @@ -0,0 +1,122 @@ +package gtPlusPlus.core.util.minecraft; + +import gregtech.api.util.GT_ModHandler; +import ic2.api.item.IElectricItem; +import ic2.api.item.IElectricItemManager; +import ic2.api.item.ISpecialElectricItem; +import net.minecraft.item.ItemStack; + +public class EnergyUtils { + + public static class EU { + + public static boolean isElectricItem(ItemStack aStack) { + if (aStack.getItem() instanceof ISpecialElectricItem) { + return true; + } + else if (aStack.getItem() instanceof IElectricItem) { + return true; + } + else if (aStack.getItem() instanceof IElectricItemManager) { + return true; + } + else { + return GT_ModHandler.isElectricItem(aStack); + } + } + + public static boolean isChargerItem(ItemStack aStack) { + return GT_ModHandler.isChargerItem(aStack); + } + + public static boolean charge(ItemStack aStack, int aEnergyToInsert, int aTier) { + return 0 != GT_ModHandler.chargeElectricItem(aStack, aEnergyToInsert, aTier, true, false); + } + + public static boolean discharge(ItemStack aStack, int aEnergyToInsert, int aTier) { + return 0 != GT_ModHandler.dischargeElectricItem(aStack, -aEnergyToInsert, aTier, true, false, true); + } + + public static long getMaxStorage(ItemStack aStack) { + if (isElectricItem(aStack)) { + if (aStack.getItem() instanceof ISpecialElectricItem) { + ISpecialElectricItem bStack = (ISpecialElectricItem) aStack.getItem(); + return (long) bStack.getMaxCharge(aStack); + } + if (aStack.getItem() instanceof IElectricItem) { + IElectricItem bStack = (IElectricItem) aStack.getItem(); + return (long) bStack.getMaxCharge(aStack); + } + if (aStack.getItem() instanceof IElectricItemManager) { + IElectricItemManager bStack = (IElectricItemManager) aStack.getItem(); + return (long) bStack.getCharge(aStack); + } + } + else { + return 0; + } + return 0; + } + + public static long getCharge(ItemStack aStack) { + if (isElectricItem(aStack)) { + if (aStack.getItem() instanceof ISpecialElectricItem) { + ISpecialElectricItem bStack = (ISpecialElectricItem) aStack.getItem(); + return (long) bStack.getManager(aStack).getCharge(aStack); + } + if (aStack.getItem() instanceof IElectricItemManager) { + IElectricItemManager bStack = (IElectricItemManager) aStack.getItem(); + return (long) bStack.getCharge(aStack); + } + } + else { + return 0; + } + return 0; + } + + public static boolean hasCharge(ItemStack aStack) { + if (isElectricItem(aStack)) { + if (aStack.getItem() instanceof ISpecialElectricItem) { + ISpecialElectricItem bStack = (ISpecialElectricItem) aStack.getItem(); + return bStack.canProvideEnergy(aStack); + } + if (aStack.getItem() instanceof IElectricItem) { + IElectricItem bStack = (IElectricItem) aStack.getItem(); + return bStack.canProvideEnergy(aStack); + } + if (aStack.getItem() instanceof IElectricItemManager) { + IElectricItemManager bStack = (IElectricItemManager) aStack.getItem(); + return bStack.getCharge(aStack) > 0; + } + } + else { + return false; + } + return false; + } + + public static int getTier(ItemStack aStack) { + if (isElectricItem(aStack)) { + if (aStack.getItem() instanceof ISpecialElectricItem) { + ISpecialElectricItem bStack = (ISpecialElectricItem) aStack.getItem(); + return bStack.getTier(aStack); + } + if (aStack.getItem() instanceof IElectricItem) { + IElectricItem bStack = (IElectricItem) aStack.getItem(); + return bStack.getTier(aStack); + } + } + else { + return 0; + } + return 0; + } + + } + + public static class RF { + + } + +} diff --git a/src/Java/gtPlusPlus/preloader/asm/transformers/ClassTransformer_GT_BusPatch.java b/src/Java/gtPlusPlus/preloader/asm/transformers/ClassTransformer_GT_BusPatch.java new file mode 100644 index 0000000000..8c7413f5b9 --- /dev/null +++ b/src/Java/gtPlusPlus/preloader/asm/transformers/ClassTransformer_GT_BusPatch.java @@ -0,0 +1,337 @@ +package gtPlusPlus.preloader.asm.transformers; + +import static org.objectweb.asm.Opcodes.AASTORE; +import static org.objectweb.asm.Opcodes.ACC_PUBLIC; +import static org.objectweb.asm.Opcodes.ACONST_NULL; +import static org.objectweb.asm.Opcodes.ALOAD; +import static org.objectweb.asm.Opcodes.ANEWARRAY; +import static org.objectweb.asm.Opcodes.ASM5; +import static org.objectweb.asm.Opcodes.DUP; +import static org.objectweb.asm.Opcodes.F_FULL; +import static org.objectweb.asm.Opcodes.GOTO; +import static org.objectweb.asm.Opcodes.ICONST_0; +import static org.objectweb.asm.Opcodes.ICONST_1; +import static org.objectweb.asm.Opcodes.ICONST_2; +import static org.objectweb.asm.Opcodes.IF_ICMPLT; +import static org.objectweb.asm.Opcodes.ILOAD; +import static org.objectweb.asm.Opcodes.INTEGER; +import static org.objectweb.asm.Opcodes.INVOKESPECIAL; +import static org.objectweb.asm.Opcodes.INVOKEVIRTUAL; +import static org.objectweb.asm.Opcodes.NEW; +import static org.objectweb.asm.Opcodes.PUTFIELD; +import static org.objectweb.asm.Opcodes.RETURN; +import static org.objectweb.asm.Opcodes.UNINITIALIZED_THIS; + +import org.apache.logging.log4j.Level; +import org.objectweb.asm.ClassReader; +import org.objectweb.asm.ClassVisitor; +import org.objectweb.asm.ClassWriter; +import org.objectweb.asm.Label; +import org.objectweb.asm.MethodVisitor; + +import cpw.mods.fml.relauncher.FMLRelaunchLog; + +public class ClassTransformer_GT_BusPatch { + + public static final String aSuperInput = "gtPlusPlus.xmod.gregtech.api.metatileentity.implementations.GT_MetaTileEntity_SuperBus_Input"; + public static final String aSuperOutput = "gtPlusPlus.xmod.gregtech.api.metatileentity.implementations.GT_MetaTileEntity_SuperBus_Output"; + public static final String aInput = "gregtech.api.metatileentity.implementations.GT_MetaTileEntity_Hatch_InputBus"; + public static final String aOutput = "gregtech.api.metatileentity.implementations.GT_MetaTileEntity_Hatch_OutputBus"; + + private final boolean isValid; + private final ClassReader reader; + private final ClassWriter writer; + + + public ClassTransformer_GT_BusPatch(byte[] basicClass, String aClassName) { + ClassReader aTempReader = null; + ClassWriter aTempWriter = null; + + FMLRelaunchLog.log("[GT++ ASM] Gregtech Bus Patch", Level.INFO, "Attempting to make GT Busses bigger."); + FMLRelaunchLog.log("[GT++ ASM] Gregtech Bus Patch", Level.INFO, "Patching "+aClassName+"."); + + aTempReader = new ClassReader(basicClass); + aTempWriter = new ClassWriter(aTempReader, ClassWriter.COMPUTE_FRAMES); + aTempReader.accept(new localClassVisitor(aTempWriter), 0); + + if (aTempReader != null && aTempWriter != null) { + isValid = true; + } + else { + isValid = false; + } + FMLRelaunchLog.log("[GT++ ASM] Gregtech Bus Patch", Level.INFO, "Valid patch? "+isValid+"."); + reader = aTempReader; + writer = aTempWriter; + + + if (reader != null && writer != null) { + FMLRelaunchLog.log("[GT++ ASM] Gregtech Bus Patch", Level.INFO, "Attempting Method Injection."); + injectMethod(aClassName); + } + + } + + public boolean isValidTransformer() { + return isValid; + } + + public ClassReader getReader() { + return reader; + } + + public ClassWriter getWriter() { + return writer; + } + + + public boolean injectMethod(String aClassName) { + + boolean didInject = false; + MethodVisitor mv; + ClassWriter cw = getWriter(); + + //GT_MetaTileEntity_Hatch_InputBus + //Constructor + if (aClassName.equals(aInput)){ + mv = cw.visitMethod(ACC_PUBLIC, "<init>", "(ILjava/lang/String;Ljava/lang/String;II)V", null, null); + mv.visitCode(); + Label l0 = new Label(); + mv.visitLabel(l0); + mv.visitLineNumber(19, l0); + mv.visitVarInsn(ALOAD, 0); + mv.visitVarInsn(ILOAD, 1); + mv.visitVarInsn(ALOAD, 2); + mv.visitVarInsn(ALOAD, 3); + mv.visitVarInsn(ILOAD, 4); + mv.visitVarInsn(ILOAD, 5); + mv.visitInsn(ICONST_2); + mv.visitTypeInsn(ANEWARRAY, "java/lang/String"); + mv.visitInsn(DUP); + mv.visitInsn(ICONST_0); + mv.visitLdcInsn("Item Input for Multiblocks"); + mv.visitInsn(AASTORE); + mv.visitInsn(DUP); + mv.visitInsn(ICONST_1); + Label l1 = new Label(); + mv.visitLabel(l1); + mv.visitLineNumber(20, l1); + mv.visitTypeInsn(NEW, "java/lang/StringBuilder"); + mv.visitInsn(DUP); + mv.visitLdcInsn("Capacity: "); + mv.visitMethodInsn(INVOKESPECIAL, "java/lang/StringBuilder", "<init>", "(Ljava/lang/String;)V", false); + mv.visitVarInsn(ILOAD, 5); + mv.visitMethodInsn(INVOKEVIRTUAL, "java/lang/StringBuilder", "append", "(I)Ljava/lang/StringBuilder;", false); + mv.visitLdcInsn(" stack"); + mv.visitMethodInsn(INVOKEVIRTUAL, "java/lang/StringBuilder", "append", "(Ljava/lang/String;)Ljava/lang/StringBuilder;", false); + mv.visitVarInsn(ILOAD, 5); + mv.visitInsn(ICONST_2); + Label l2 = new Label(); + mv.visitJumpInsn(IF_ICMPLT, l2); + mv.visitLdcInsn("s"); + Label l3 = new Label(); + mv.visitJumpInsn(GOTO, l3); + mv.visitLabel(l2); + mv.visitFrame(F_FULL, 6, new Object[] {UNINITIALIZED_THIS, INTEGER, "java/lang/String", "java/lang/String", INTEGER, INTEGER}, 10, new Object[] {UNINITIALIZED_THIS, INTEGER, "java/lang/String", "java/lang/String", INTEGER, INTEGER, "[Ljava/lang/String;", "[Ljava/lang/String;", INTEGER, "java/lang/StringBuilder"}); + mv.visitLdcInsn(""); + mv.visitLabel(l3); + mv.visitFrame(F_FULL, 6, new Object[] {UNINITIALIZED_THIS, INTEGER, "java/lang/String", "java/lang/String", INTEGER, INTEGER}, 11, new Object[] {UNINITIALIZED_THIS, INTEGER, "java/lang/String", "java/lang/String", INTEGER, INTEGER, "[Ljava/lang/String;", "[Ljava/lang/String;", INTEGER, "java/lang/StringBuilder", "java/lang/String"}); + mv.visitMethodInsn(INVOKEVIRTUAL, "java/lang/StringBuilder", "append", "(Ljava/lang/String;)Ljava/lang/StringBuilder;", false); + mv.visitMethodInsn(INVOKEVIRTUAL, "java/lang/StringBuilder", "toString", "()Ljava/lang/String;", false); + mv.visitInsn(AASTORE); + mv.visitInsn(ICONST_0); + mv.visitTypeInsn(ANEWARRAY, "gregtech/api/interfaces/ITexture"); + mv.visitMethodInsn(INVOKESPECIAL, "gregtech/api/metatileentity/implementations/GT_MetaTileEntity_Hatch", "<init>", "(ILjava/lang/String;Ljava/lang/String;II[Ljava/lang/String;[Lgregtech/api/interfaces/ITexture;)V", false); + Label l4 = new Label(); + mv.visitLabel(l4); + mv.visitLineNumber(16, l4); + mv.visitVarInsn(ALOAD, 0); + mv.visitInsn(ACONST_NULL); + mv.visitFieldInsn(PUTFIELD, "gregtech/api/metatileentity/implementations/GT_MetaTileEntity_Hatch_InputBus", "mRecipeMap", "Lgregtech/api/util/GT_Recipe$GT_Recipe_Map;"); + Label l5 = new Label(); + mv.visitLabel(l5); + mv.visitLineNumber(21, l5); + mv.visitInsn(RETURN); + Label l6 = new Label(); + mv.visitLabel(l6); + mv.visitLocalVariable("this", "Lgregtech/api/metatileentity/implementations/GT_MetaTileEntity_Hatch_InputBus;", null, l0, l6, 0); + mv.visitLocalVariable("aID", "I", null, l0, l6, 1); + mv.visitLocalVariable("aName", "Ljava/lang/String;", null, l0, l6, 2); + mv.visitLocalVariable("aNameRegional", "Ljava/lang/String;", null, l0, l6, 3); + mv.visitLocalVariable("aTier", "I", null, l0, l6, 4); + mv.visitLocalVariable("aSlots", "I", null, l0, l6, 5); + mv.visitMaxs(12, 6); + mv.visitEnd(); + didInject = true; + } + + + //GT_MetaTileEntity_Hatch_OutputBus + //Constructor + if (aClassName.equals(aOutput)){ + mv = cw.visitMethod(ACC_PUBLIC, "<init>", "(ILjava/lang/String;Ljava/lang/String;II)V", null, null); + mv.visitCode(); + Label l0 = new Label(); + mv.visitLabel(l0); + mv.visitLineNumber(16, l0); + mv.visitVarInsn(ALOAD, 0); + mv.visitVarInsn(ILOAD, 1); + mv.visitVarInsn(ALOAD, 2); + mv.visitVarInsn(ALOAD, 3); + mv.visitVarInsn(ILOAD, 4); + mv.visitVarInsn(ILOAD, 5); + mv.visitInsn(ICONST_2); + mv.visitTypeInsn(ANEWARRAY, "java/lang/String"); + mv.visitInsn(DUP); + mv.visitInsn(ICONST_0); + mv.visitLdcInsn("Item Output for Multiblocks"); + mv.visitInsn(AASTORE); + mv.visitInsn(DUP); + mv.visitInsn(ICONST_1); + Label l1 = new Label(); + mv.visitLabel(l1); + mv.visitLineNumber(17, l1); + mv.visitTypeInsn(NEW, "java/lang/StringBuilder"); + mv.visitInsn(DUP); + mv.visitLdcInsn("Capacity: "); + mv.visitMethodInsn(INVOKESPECIAL, "java/lang/StringBuilder", "<init>", "(Ljava/lang/String;)V", false); + mv.visitVarInsn(ILOAD, 5); + mv.visitMethodInsn(INVOKEVIRTUAL, "java/lang/StringBuilder", "append", "(I)Ljava/lang/StringBuilder;", false); + mv.visitLdcInsn(" stack"); + mv.visitMethodInsn(INVOKEVIRTUAL, "java/lang/StringBuilder", "append", "(Ljava/lang/String;)Ljava/lang/StringBuilder;", false); + mv.visitVarInsn(ILOAD, 5); + mv.visitInsn(ICONST_2); + Label l2 = new Label(); + mv.visitJumpInsn(IF_ICMPLT, l2); + mv.visitLdcInsn("s"); + Label l3 = new Label(); + mv.visitJumpInsn(GOTO, l3); + mv.visitLabel(l2); + mv.visitFrame(F_FULL, 6, new Object[] {UNINITIALIZED_THIS, INTEGER, "java/lang/String", "java/lang/String", INTEGER, INTEGER}, 10, new Object[] {UNINITIALIZED_THIS, INTEGER, "java/lang/String", "java/lang/String", INTEGER, INTEGER, "[Ljava/lang/String;", "[Ljava/lang/String;", INTEGER, "java/lang/StringBuilder"}); + mv.visitLdcInsn(""); + mv.visitLabel(l3); + mv.visitFrame(F_FULL, 6, new Object[] {UNINITIALIZED_THIS, INTEGER, "java/lang/String", "java/lang/String", INTEGER, INTEGER}, 11, new Object[] {UNINITIALIZED_THIS, INTEGER, "java/lang/String", "java/lang/String", INTEGER, INTEGER, "[Ljava/lang/String;", "[Ljava/lang/String;", INTEGER, "java/lang/StringBuilder", "java/lang/String"}); + mv.visitMethodInsn(INVOKEVIRTUAL, "java/lang/StringBuilder", "append", "(Ljava/lang/String;)Ljava/lang/StringBuilder;", false); + mv.visitMethodInsn(INVOKEVIRTUAL, "java/lang/StringBuilder", "toString", "()Ljava/lang/String;", false); + mv.visitInsn(AASTORE); + mv.visitInsn(ICONST_0); + mv.visitTypeInsn(ANEWARRAY, "gregtech/api/interfaces/ITexture"); + mv.visitMethodInsn(INVOKESPECIAL, "gregtech/api/metatileentity/implementations/GT_MetaTileEntity_Hatch", "<init>", "(ILjava/lang/String;Ljava/lang/String;II[Ljava/lang/String;[Lgregtech/api/interfaces/ITexture;)V", false); + Label l4 = new Label(); + mv.visitLabel(l4); + mv.visitLineNumber(18, l4); + mv.visitInsn(RETURN); + Label l5 = new Label(); + mv.visitLabel(l5); + mv.visitLocalVariable("this", "Lgregtech/api/metatileentity/implementations/GT_MetaTileEntity_Hatch_OutputBus;", null, l0, l5, 0); + mv.visitLocalVariable("aID", "I", null, l0, l5, 1); + mv.visitLocalVariable("aName", "Ljava/lang/String;", null, l0, l5, 2); + mv.visitLocalVariable("aNameRegional", "Ljava/lang/String;", null, l0, l5, 3); + mv.visitLocalVariable("aTier", "I", null, l0, l5, 4); + mv.visitLocalVariable("aSlots", "I", null, l0, l5, 5); + mv.visitMaxs(12, 6); + mv.visitEnd(); + didInject = true; + } + + + //GT_MetaTileEntity_SuperBus_Input + //Constructor + if (aClassName.equals(aSuperInput)){ + mv = cw.visitMethod(ACC_PUBLIC, "<init>", "(ILjava/lang/String;Ljava/lang/String;II)V", null, null); + mv.visitCode(); + Label l0 = new Label(); + mv.visitLabel(l0); + mv.visitLineNumber(27, l0); + mv.visitVarInsn(ALOAD, 0); + mv.visitVarInsn(ILOAD, 1); + mv.visitVarInsn(ALOAD, 2); + mv.visitVarInsn(ALOAD, 3); + mv.visitVarInsn(ILOAD, 4); + mv.visitMethodInsn(INVOKESPECIAL, "gregtech/api/metatileentity/implementations/GT_MetaTileEntity_Hatch_InputBus", "<init>", "(ILjava/lang/String;Ljava/lang/String;I)V", false); + Label l1 = new Label(); + mv.visitLabel(l1); + mv.visitLineNumber(20, l1); + mv.visitVarInsn(ALOAD, 0); + mv.visitInsn(ACONST_NULL); + mv.visitFieldInsn(PUTFIELD, "gtPlusPlus/xmod/gregtech/api/metatileentity/implementations/GT_MetaTileEntity_SuperBus_Input", "mRecipeMap", "Lgregtech/api/util/GT_Recipe$GT_Recipe_Map;"); + Label l2 = new Label(); + mv.visitLabel(l2); + mv.visitLineNumber(28, l2); + mv.visitInsn(RETURN); + Label l3 = new Label(); + mv.visitLabel(l3); + mv.visitLocalVariable("this", "LgtPlusPlus/xmod/gregtech/api/metatileentity/implementations/GT_MetaTileEntity_SuperBus_Input;", null, l0, l3, 0); + mv.visitLocalVariable("aID", "I", null, l0, l3, 1); + mv.visitLocalVariable("aName", "Ljava/lang/String;", null, l0, l3, 2); + mv.visitLocalVariable("aNameRegional", "Ljava/lang/String;", null, l0, l3, 3); + mv.visitLocalVariable("aTier", "I", null, l0, l3, 4); + mv.visitLocalVariable("aSlots", "I", null, l0, l3, 5); + mv.visitMaxs(5, 6); + mv.visitEnd(); + didInject = true; + } + + + //GT_MetaTileEntity_SuperBus_Output + //Constructor + if (aClassName.equals(aSuperOutput)){ + mv = cw.visitMethod(ACC_PUBLIC, "<init>", "(ILjava/lang/String;Ljava/lang/String;II)V", null, null); + mv.visitCode(); + Label l0 = new Label(); + mv.visitLabel(l0); + mv.visitLineNumber(25, l0); + mv.visitVarInsn(ALOAD, 0); + mv.visitVarInsn(ILOAD, 1); + mv.visitVarInsn(ALOAD, 2); + mv.visitVarInsn(ALOAD, 3); + mv.visitVarInsn(ILOAD, 4); + mv.visitMethodInsn(INVOKESPECIAL, "gregtech/api/metatileentity/implementations/GT_MetaTileEntity_Hatch_OutputBus", "<init>", "(ILjava/lang/String;Ljava/lang/String;I)V", false); + Label l1 = new Label(); + mv.visitLabel(l1); + mv.visitLineNumber(18, l1); + mv.visitVarInsn(ALOAD, 0); + mv.visitInsn(ACONST_NULL); + mv.visitFieldInsn(PUTFIELD, "gtPlusPlus/xmod/gregtech/api/metatileentity/implementations/GT_MetaTileEntity_SuperBus_Output", "mRecipeMap", "Lgregtech/api/util/GT_Recipe$GT_Recipe_Map;"); + Label l2 = new Label(); + mv.visitLabel(l2); + mv.visitLineNumber(26, l2); + mv.visitInsn(RETURN); + Label l3 = new Label(); + mv.visitLabel(l3); + mv.visitLocalVariable("this", "LgtPlusPlus/xmod/gregtech/api/metatileentity/implementations/GT_MetaTileEntity_SuperBus_Output;", null, l0, l3, 0); + mv.visitLocalVariable("aID", "I", null, l0, l3, 1); + mv.visitLocalVariable("aName", "Ljava/lang/String;", null, l0, l3, 2); + mv.visitLocalVariable("aNameRegional", "Ljava/lang/String;", null, l0, l3, 3); + mv.visitLocalVariable("aTier", "I", null, l0, l3, 4); + mv.visitLocalVariable("aSlots", "I", null, l0, l3, 5); + mv.visitMaxs(5, 6); + mv.visitEnd(); + didInject = true; + } + + + + FMLRelaunchLog.log("[GT++ ASM] Gregtech Bus Patch", Level.INFO, "Method injection complete."); + return didInject; + + + + } + + public final class localClassVisitor extends ClassVisitor { + + public localClassVisitor(ClassVisitor cv) { + super(ASM5, cv); + } + + @Override + public MethodVisitor visitMethod(int access, String name, String desc, String signature, String[] exceptions) { + MethodVisitor methodVisitor; + methodVisitor = super.visitMethod(access, name, desc, signature, exceptions); + return methodVisitor; + } + } + + +} diff --git a/src/Java/gtPlusPlus/preloader/asm/transformers/Preloader_Transformer_Handler.java b/src/Java/gtPlusPlus/preloader/asm/transformers/Preloader_Transformer_Handler.java index 5642b700f5..e12213003f 100644 --- a/src/Java/gtPlusPlus/preloader/asm/transformers/Preloader_Transformer_Handler.java +++ b/src/Java/gtPlusPlus/preloader/asm/transformers/Preloader_Transformer_Handler.java @@ -127,6 +127,11 @@ public class Preloader_Transformer_Handler implements IClassTransformer { FMLRelaunchLog.log("[GT++ ASM] Gregtech Utilities Patch", Level.INFO, "Transforming %s", transformedName); return new ClassTransformer_GT_Utility(basicClass, transformedName).getWriter().toByteArray(); } + //Inject Custom constructors for Busses + if (transformedName.equals(ClassTransformer_GT_BusPatch.aInput) || transformedName.equals(ClassTransformer_GT_BusPatch.aOutput) || transformedName.equals(ClassTransformer_GT_BusPatch.aSuperInput) || transformedName.equals(ClassTransformer_GT_BusPatch.aSuperOutput)) { + FMLRelaunchLog.log("[GT++ ASM] Gregtech Bus Patch", Level.INFO, "Transforming %s", transformedName); + return new ClassTransformer_GT_BusPatch(basicClass, transformedName).getWriter().toByteArray(); + } //Try patch achievements if (transformedName.equals("gregtech.loaders.misc.GT_Achievements")) { FMLRelaunchLog.log("[GT++ ASM] Gregtech Achievements Patch", Level.INFO, "Transforming %s", transformedName); diff --git a/src/Java/gtPlusPlus/xmod/gregtech/api/enums/GregtechItemList.java b/src/Java/gtPlusPlus/xmod/gregtech/api/enums/GregtechItemList.java index 9b300b1ced..68fe121081 100644 --- a/src/Java/gtPlusPlus/xmod/gregtech/api/enums/GregtechItemList.java +++ b/src/Java/gtPlusPlus/xmod/gregtech/api/enums/GregtechItemList.java @@ -109,6 +109,13 @@ public enum GregtechItemList implements GregtechItemContainer { Bomb_Cast_Set, Bomb_Cast_Broken, Bomb_Cast_Mold, + //Charged Items for Tree Farms + Farm_Processor_EV, + Farm_Processor_IV, + Farm_Processor_LuV, + Farm_Processor_ZPM, + Farm_Processor_UV, + //---------------------------------------------------------------------------- @@ -575,7 +582,7 @@ public enum GregtechItemList implements GregtechItemContainer { */ //Fluid Void Covers - Cover_Overflow_ULV, Cover_Overflow_LV, Cover_Overflow_MV, Cover_Overflow_HV, Cover_Overflow_EV, Cover_Overflow_IV, + Cover_Overflow_ULV, Cover_Overflow_LV, Cover_Overflow_MV, Cover_Overflow_HV, Cover_Overflow_EV, Cover_Overflow_IV, diff --git a/src/Java/gtPlusPlus/xmod/gregtech/common/helpers/TreeFarmHelper.java b/src/Java/gtPlusPlus/xmod/gregtech/common/helpers/TreeFarmHelper.java index a87fac1dfd..4038d5bdf4 100644 --- a/src/Java/gtPlusPlus/xmod/gregtech/common/helpers/TreeFarmHelper.java +++ b/src/Java/gtPlusPlus/xmod/gregtech/common/helpers/TreeFarmHelper.java @@ -48,6 +48,7 @@ import gtPlusPlus.core.util.minecraft.FluidUtils; import gtPlusPlus.core.util.minecraft.ItemUtils; import gtPlusPlus.core.util.minecraft.particles.BlockBreakParticles; import gtPlusPlus.core.util.reflect.ReflectionUtils; +import gtPlusPlus.xmod.gregtech.common.items.MetaGeneratedGregtechItems; import net.minecraftforge.common.ForgeHooks; import net.minecraftforge.common.MinecraftForge; import net.minecraftforge.event.entity.player.BonemealEvent; @@ -289,6 +290,42 @@ public class TreeFarmHelper { public static boolean isCorrectPart(final ItemStack aStack) { if (aStack != null){ //Utils.LOG_WARNING("Found "+aStack.getDisplayName()+" in the GUI slot."); + + if (aStack.getItem() instanceof MetaGeneratedGregtechItems) { + int aDmg = aStack.getItemDamage(); + if (aDmg >= 32120 && aDmg <= 32128) { + return true; + } + else if (aStack.getUnlocalizedName().toLowerCase().contains("mu-metaitem")) { + String[] aData = aStack.getUnlocalizedName().toLowerCase().split("."); + if (aData != null && aData.length > 0) { + for (String s : aData) { + if (s.contains("32120")) { + return true; + } + else if (s.contains("32122")) { + return true; + } + else if (s.contains("32124")) { + return true; + } + else if (s.contains("32126")) { + return true; + } + else if (s.contains("32128")) { + return true; + } + else { + Logger.INFO("bad Tool in Slot 1"); + return false; + } + } + } + } + Logger.INFO("bad Tool in Slot 2 | "+aStack.getUnlocalizedName().toLowerCase() + " | "+aDmg); + return false; + } + if ((aStack.getItem() instanceof GT_MetaGenerated_Item_02) || (aStack.getItem() instanceof GT_MetaGenerated_Tool)){ if (OrePrefixes.craftingTool.contains(aStack)){ if (aStack.getDisplayName().toLowerCase().contains("saw") || aStack.getDisplayName().toLowerCase().contains("gt.metatool.01")){ @@ -308,12 +345,14 @@ public class TreeFarmHelper { return true; } else { + Logger.INFO("bad Tool in Slot 3"); return false; } } } } } + Logger.INFO("bad Tool in Slot 4"); return false; } diff --git a/src/Java/gtPlusPlus/xmod/gregtech/common/items/MetaGeneratedGregtechItems.java b/src/Java/gtPlusPlus/xmod/gregtech/common/items/MetaGeneratedGregtechItems.java index f42fc49e53..1a400eaa20 100644 --- a/src/Java/gtPlusPlus/xmod/gregtech/common/items/MetaGeneratedGregtechItems.java +++ b/src/Java/gtPlusPlus/xmod/gregtech/common/items/MetaGeneratedGregtechItems.java @@ -313,7 +313,19 @@ public class MetaGeneratedGregtechItems extends Gregtech_MetaItem_X32 { GregtechItemList.Bomb_Cast_Broken.set(this.addItem(114, "Bomb Cast (Broken)", "This is probably just junk", new Object[0])); GregtechItemList.Bomb_Cast_Mold.set(this.addItem(115, "Mold (Bomb Cast)", "Used in the production of Bombs", new Object[0])); - + /* + * High Tier 'Saws' for the tree Farm + */ + GregtechItemList.Farm_Processor_EV.set(this.addItem(tLastID = 120, "Farm Processor [EV]", "Reusable", new Object[]{getTcAspectStack(TC_Aspects.ELECTRUM, 8L), getTcAspectStack(TC_Aspects.METALLUM, 8L), getTcAspectStack(TC_Aspects.POTENTIA, 8L)})); + this.setElectricStats(32000 + tLastID, GT_Values.V[5]* 10 * 60 * 20, GT_Values.V[4], 4L, -3L, false); + GregtechItemList.Farm_Processor_IV.set(this.addItem(tLastID = 122, "Farm Processor [IV]", "Reusable", new Object[]{getTcAspectStack(TC_Aspects.ELECTRUM, 8L), getTcAspectStack(TC_Aspects.METALLUM, 8L), getTcAspectStack(TC_Aspects.POTENTIA, 8L)})); + this.setElectricStats(32000 + tLastID, GT_Values.V[6]* 10 * 60 * 20, GT_Values.V[5], 5L, -3L, false); + GregtechItemList.Farm_Processor_LuV.set(this.addItem(tLastID = 124, "Farm Processor [LuV]", "Reusable", new Object[]{getTcAspectStack(TC_Aspects.ELECTRUM, 8L), getTcAspectStack(TC_Aspects.METALLUM, 8L), getTcAspectStack(TC_Aspects.POTENTIA, 8L)})); + this.setElectricStats(32000 + tLastID, GT_Values.V[7]* 10 * 60 * 20, GT_Values.V[6], 6L, -3L, false); + GregtechItemList.Farm_Processor_ZPM.set(this.addItem(tLastID = 126, "Farm Processor [ZPM]", "Reusable", new Object[]{getTcAspectStack(TC_Aspects.ELECTRUM, 8L), getTcAspectStack(TC_Aspects.METALLUM, 8L), getTcAspectStack(TC_Aspects.POTENTIA, 8L)})); + this.setElectricStats(32000 + tLastID, GT_Values.V[8]* 10 * 60 * 20, GT_Values.V[7], 7L, -3L, false); + GregtechItemList.Farm_Processor_UV.set(this.addItem(tLastID = 128, "Farm Processor [UV]", "Reusable", new Object[]{getTcAspectStack(TC_Aspects.ELECTRUM, 8L), getTcAspectStack(TC_Aspects.METALLUM, 8L), getTcAspectStack(TC_Aspects.POTENTIA, 8L)})); + this.setElectricStats(32000 + tLastID, GT_Values.V[9]* 10 * 60 * 20, GT_Values.V[8], 8L, -3L, false); diff --git a/src/Java/gtPlusPlus/xmod/gregtech/common/tileentities/machines/multi/production/GregtechMetaTileEntityTreeFarm.java b/src/Java/gtPlusPlus/xmod/gregtech/common/tileentities/machines/multi/production/GregtechMetaTileEntityTreeFarm.java index fc4611686f..9fb9e3514e 100644 --- a/src/Java/gtPlusPlus/xmod/gregtech/common/tileentities/machines/multi/production/GregtechMetaTileEntityTreeFarm.java +++ b/src/Java/gtPlusPlus/xmod/gregtech/common/tileentities/machines/multi/production/GregtechMetaTileEntityTreeFarm.java @@ -1,8 +1,6 @@ package gtPlusPlus.xmod.gregtech.common.tileentities.machines.multi.production; -import java.util.concurrent.Executors; import java.util.concurrent.ScheduledExecutorService; -import java.util.concurrent.TimeUnit; import gregtech.api.GregTech_API; import gregtech.api.enums.TAE; @@ -11,6 +9,7 @@ import gregtech.api.interfaces.IIconContainer; import gregtech.api.interfaces.ITexture; import gregtech.api.interfaces.metatileentity.IMetaTileEntity; import gregtech.api.interfaces.tileentity.IGregTechTileEntity; +import gregtech.api.items.GT_MetaGenerated_Tool; import gregtech.api.objects.GT_RenderedTexture; import gregtech.api.util.GT_Recipe; import gregtech.api.util.GT_Utility; @@ -19,6 +18,8 @@ import gtPlusPlus.api.objects.data.AutoMap; import gtPlusPlus.api.objects.minecraft.ThreadFakeWorldGenerator; import gtPlusPlus.core.block.ModBlocks; import gtPlusPlus.core.util.math.MathUtils; +import gtPlusPlus.core.util.minecraft.EnergyUtils; +import gtPlusPlus.core.util.minecraft.EnergyUtils.EU; import gtPlusPlus.core.util.minecraft.FluidUtils; import gtPlusPlus.core.util.minecraft.ItemUtils; import gtPlusPlus.xmod.gregtech.api.metatileentity.implementations.base.GregtechMeta_MultiBlockBase; @@ -34,39 +35,30 @@ import net.minecraftforge.fluids.FluidStack; public class GregtechMetaTileEntityTreeFarm extends GregtechMeta_MultiBlockBase { public static int CASING_TEXTURE_ID; - public static String mCryoFuelName = "Gelid Cryotheum"; public static String mCasingName = "Advanced Cryogenic Casing"; - public static String mHatchName = "Cryotheum Hatch"; - public static FluidStack mFuelStack; public static TreeGenerator mTreeData; public GregtechMetaTileEntityTreeFarm(final int aID, final String aName, final String aNameRegional) { super(aID, aName, aNameRegional); - mFuelStack = FluidUtils.getFluidStack("cryotheum", 1); CASING_TEXTURE_ID = TAE.getIndexFromPage(1, 15); - mCryoFuelName = mFuelStack.getLocalizedName(); mCasingName = ItemUtils.getLocalizedNameOfBlock(ModBlocks.blockCasings2Misc, 15); - mHatchName = ItemUtils.getLocalizedNameOfBlock(GregTech_API.sBlockMachines, 967); } - - + + /* * Static thread for Fake World Handling */ - - + + private static ScheduledExecutorService executor; private static ThreadFakeWorldGenerator aThread; - + public GregtechMetaTileEntityTreeFarm(final String aName) { super(aName); - mFuelStack = FluidUtils.getFluidStack("cryotheum", 1); CASING_TEXTURE_ID = TAE.getIndexFromPage(1, 15); - mCryoFuelName = mFuelStack.getLocalizedName(); mCasingName = ItemUtils.getLocalizedNameOfBlock(ModBlocks.blockCasings2Misc, 15); - mHatchName = ItemUtils.getLocalizedNameOfBlock(GregTech_API.sBlockMachines, 967); - + /*if (executor == null || mTreeData == null) { if (executor == null) { executor = Executors.newScheduledThreadPool(10); @@ -86,14 +78,14 @@ public class GregtechMetaTileEntityTreeFarm extends GregtechMeta_MultiBlockBase } } }*/ - + if (mTreeData == null) { mTreeData = new TreeGenerator(); } - - - + + + } public IMetaTileEntity newMetaEntity(final IGregTechTileEntity aTileEntity) { @@ -110,20 +102,13 @@ public class GregtechMetaTileEntityTreeFarm extends GregtechMeta_MultiBlockBase if (mCasingName.toLowerCase().contains(".name")) { mCasingName = ItemUtils.getLocalizedNameOfBlock(ModBlocks.blockCasings2Misc, 15); } - if (mCryoFuelName.toLowerCase().contains(".")) { - mCryoFuelName = FluidUtils.getFluidStack("cryotheum", 1).getLocalizedName(); - } - if (mHatchName.toLowerCase().contains(".name")) { - mHatchName = ItemUtils.getLocalizedNameOfBlock(GregTech_API.sBlockMachines, 967); - } - + return new String[]{ - "Factory Grade Tree Growth Simulator", + "Converts EU to Oak Logs", "Speed: Very Fast | Eu Usage: 100% | Parallel: 1", - //"Consumes 1L of "+mCryoFuelName+"/t during operation", + "Requires a Saw, Buzz Saw or Chainsaw in GUI slot", "Constructed exactly the same as a normal Vacuum Freezer", "Use "+mCasingName+"s (10 at least!)", - "1x " + mHatchName + " (Required)", "TAG_HIDE_HATCHES" }; } @@ -141,7 +126,7 @@ public class GregtechMetaTileEntityTreeFarm extends GregtechMeta_MultiBlockBase public boolean hasSlotInGUI() { return true; } - + @Override public boolean requiresVanillaGtGUI() { return true; @@ -157,8 +142,8 @@ public class GregtechMetaTileEntityTreeFarm extends GregtechMeta_MultiBlockBase } public boolean isCorrectMachinePart(final ItemStack aStack) { - //return TreeFarmHelper.isCorrectPart(aStack); - return true; + return TreeFarmHelper.isCorrectPart(aStack); + //return true; } public boolean isFacingValid(final byte aFacing) { @@ -169,13 +154,13 @@ public class GregtechMetaTileEntityTreeFarm extends GregtechMeta_MultiBlockBase //Logger.WARNING("Trying to process virtual tree farming"); if (mTreeData != null) { //Logger.WARNING("Tree Data is valid"); - + long tVoltage = getMaxInputVoltage(); byte tTier = (byte) Math.max(1, GT_Utility.getTier(tVoltage)); - + this.mMaxProgresstime = 100; this.mEUt = (int) tVoltage; - + this.mEfficiency = (10000 - (getIdealStatus() - getRepairStatus()) * 1000); this.mEfficiencyIncrease = 10000; @@ -193,39 +178,39 @@ public class GregtechMetaTileEntityTreeFarm extends GregtechMeta_MultiBlockBase if (this.mEUt > 0) { this.mEUt = (-this.mEUt); } - - - + + + int aChance = MathUtils.randInt(0, 10); AutoMap<ItemStack> aOutputs = new AutoMap<ItemStack>(); - + try { //Logger.WARNING("Output Chance - "+aChance+" | Valid number? "+(aChance < 1000)); - if (aChance < 8) { - //1% Chance per Tick - for (int u=0; u<(Math.max(20, (MathUtils.randInt((3*tTier), 100)*tTier*tTier)/8));u++) { - aOutputs = mTreeData.generateOutput(0); - if (aOutputs.size() > 0) { - Logger.WARNING("Generated some Loot, adding it to the output busses"); - - ItemStack aLeaves = ItemUtils.getSimpleStack(Blocks.leaves); - - for (ItemStack aOutputItemStack : aOutputs) { - if (!GT_Utility.areStacksEqual(aLeaves, aOutputItemStack)) { - this.addOutput(aOutputItemStack); + if (aChance < 8) { + //1% Chance per Tick + for (int u=0; u<(Math.max(20, (MathUtils.randInt((3*tTier), 100)*tTier*tTier)/8));u++) { + aOutputs = mTreeData.generateOutput(0); + if (aOutputs.size() > 0) { + Logger.WARNING("Generated some Loot, adding it to the output busses"); + + ItemStack aLeaves = ItemUtils.getSimpleStack(Blocks.leaves); + + for (ItemStack aOutputItemStack : aOutputs) { + if (!GT_Utility.areStacksEqual(aLeaves, aOutputItemStack)) { + this.addOutput(aOutputItemStack); + } } - } - Logger.WARNING("Updating Slots"); - this.updateSlots(); - } - } - - } + Logger.WARNING("Updating Slots"); + this.updateSlots(); + } + } + + } } catch (Throwable t) { t.printStackTrace(); } - + //Logger.WARNING("Valid Recipe"); return true; } @@ -235,7 +220,7 @@ public class GregtechMetaTileEntityTreeFarm extends GregtechMeta_MultiBlockBase } //return this.checkRecipeGeneric(4, 100, 100); } - + @Override public int getMaxParallelRecipes() { return 1; @@ -282,11 +267,11 @@ public class GregtechMetaTileEntityTreeFarm extends GregtechMeta_MultiBlockBase } public int getPollutionPerTick(final ItemStack aStack) { - return 25; + return 5; } public int getDamageToComponent(final ItemStack aStack) { - return 0; + return MathUtils.balance((int) (75 - ((GT_MetaGenerated_Tool.getPrimaryMaterial(aStack).getMass()))), 5, 120); } public boolean explodesOnComponentBreak(final ItemStack aStack) { @@ -294,17 +279,42 @@ public class GregtechMetaTileEntityTreeFarm extends GregtechMeta_MultiBlockBase } @Override - public void onPostTick(IGregTechTileEntity aBaseMetaTileEntity, long aTick) { - if (mTreeData != null) { - //this.getBaseMetaTileEntity().enableWorking(); - } - - - /*if (this.getBaseMetaTileEntity().isActive()) { - if (!this.depleteInput(mFuelStack.copy())) { - this.getBaseMetaTileEntity().setActive(false); - } - } */ - super.onPostTick(aBaseMetaTileEntity, aTick); + public void onPostTick(IGregTechTileEntity aBaseMetaTileEntity, long aTick) { + super.onPostTick(aBaseMetaTileEntity, aTick); + if (this.mInventory[1] != null && aTick % 200 == 0 && this.getBaseMetaTileEntity().isServerSide()) { + ItemStack invItem = this.mInventory[1]; + if (isCorrectMachinePart(invItem)) { + + boolean didElectricDamage = false; + if (EU.isElectricItem(invItem)) { + if (EU.hasCharge(invItem)) { + long tVoltage = getMaxInputVoltage(); + byte tTier = (byte) Math.max(1, GT_Utility.getTier(tVoltage)); + if (EU.getCharge(invItem) >= tVoltage) { + if (EU.discharge(invItem, (int) tVoltage, tTier)) { + } + else { + this.getBaseMetaTileEntity().disableWorking(); + } + didElectricDamage = true; + } + } + } + + + //Logger.INFO("dmg: "+aDmg+" | max: "+aDmgMax); + + if (!didElectricDamage) { + long aDmg = GT_MetaGenerated_Tool.getToolDamage(invItem); + long aDmgMax = GT_MetaGenerated_Tool.getToolMaxDamage(invItem); + if (aDmg < aDmgMax && invItem.isItemStackDamageable()) { + GT_MetaGenerated_Tool.setToolDamage(invItem, aDmg+getDamageToComponent(invItem)); + } + else if (aDmg >= aDmgMax) { + this.mInventory[1] = null; + } + } + } + } } }
\ No newline at end of file diff --git a/src/Java/gtPlusPlus/xmod/gregtech/registration/gregtech/GregtechCustomHatches.java b/src/Java/gtPlusPlus/xmod/gregtech/registration/gregtech/GregtechCustomHatches.java index 9a12acaaf1..45a23fb184 100644 --- a/src/Java/gtPlusPlus/xmod/gregtech/registration/gregtech/GregtechCustomHatches.java +++ b/src/Java/gtPlusPlus/xmod/gregtech/registration/gregtech/GregtechCustomHatches.java @@ -1,8 +1,9 @@ package gtPlusPlus.xmod.gregtech.registration.gregtech; -import gregtech.api.enums.ItemList; -import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_Hatch_InputBus; -import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_Hatch_OutputBus; +import java.lang.reflect.Constructor; +import java.lang.reflect.InvocationTargetException; + +import gregtech.api.interfaces.metatileentity.IMetaTileEntity; import gtPlusPlus.api.objects.Logger; import gtPlusPlus.core.lib.CORE; import gtPlusPlus.core.util.minecraft.FluidUtils; @@ -100,41 +101,47 @@ public class GregtechCustomHatches { private static void run3() { + + /* * Super Input Busses */ int aStartID = 30021; + Class aGT_MetaTileEntity_SuperBus_Input = GT_MetaTileEntity_SuperBus_Input.class; + Class aGT_MetaTileEntity_SuperBus_Output = GT_MetaTileEntity_SuperBus_Output.class; + + GregtechItemList.Hatch_SuperBus_Input_ULV - .set((new GT_MetaTileEntity_SuperBus_Input(aStartID++, "hatch.superbus.input.tier.00", "Super Bus (I) (ULV)", 0)) + .set(((IMetaTileEntity) generateBus(aGT_MetaTileEntity_SuperBus_Input, aStartID++, "hatch.superbus.input.tier.00", "Super Bus (I) (ULV)", 0)) .getStackForm(1L)); GregtechItemList.Hatch_SuperBus_Input_LV - .set((new GT_MetaTileEntity_SuperBus_Input(aStartID++, "hatch.superbus.input.tier.01", "Super Bus (I) (LV)", 1)) + .set(((IMetaTileEntity) generateBus(aGT_MetaTileEntity_SuperBus_Input, aStartID++, "hatch.superbus.input.tier.01", "Super Bus (I) (LV)", 1)) .getStackForm(1L)); GregtechItemList.Hatch_SuperBus_Input_MV - .set((new GT_MetaTileEntity_SuperBus_Input(aStartID++, "hatch.superbus.input.tier.02", "Super Bus (I) (MV)", 2)) + .set(((IMetaTileEntity) generateBus(aGT_MetaTileEntity_SuperBus_Input, aStartID++, "hatch.superbus.input.tier.02", "Super Bus (I) (MV)", 2)) .getStackForm(1L)); GregtechItemList.Hatch_SuperBus_Input_HV - .set((new GT_MetaTileEntity_SuperBus_Input(aStartID++, "hatch.superbus.input.tier.03", "Super Bus (I) (HV)", 3)) + .set(((IMetaTileEntity) generateBus(aGT_MetaTileEntity_SuperBus_Input, aStartID++, "hatch.superbus.input.tier.03", "Super Bus (I) (HV)", 3)) .getStackForm(1L)); GregtechItemList.Hatch_SuperBus_Input_EV - .set((new GT_MetaTileEntity_SuperBus_Input(aStartID++, "hatch.superbus.input.tier.04", "Super Bus (I) (EV)", 4)) + .set(((IMetaTileEntity) generateBus(aGT_MetaTileEntity_SuperBus_Input, aStartID++, "hatch.superbus.input.tier.04", "Super Bus (I) (EV)", 4)) .getStackForm(1L)); GregtechItemList.Hatch_SuperBus_Input_IV - .set((new GT_MetaTileEntity_SuperBus_Input(aStartID++, "hatch.superbus.input.tier.05", "Super Bus (I) (IV)", 5)) + .set(((IMetaTileEntity) generateBus(aGT_MetaTileEntity_SuperBus_Input, aStartID++, "hatch.superbus.input.tier.05", "Super Bus (I) (IV)", 5)) .getStackForm(1L)); GregtechItemList.Hatch_SuperBus_Input_LuV - .set((new GT_MetaTileEntity_SuperBus_Input(aStartID++, "hatch.superbus.input.tier.06", "Super Bus (I) (LuV)", 6)) + .set(((IMetaTileEntity) generateBus(aGT_MetaTileEntity_SuperBus_Input, aStartID++, "hatch.superbus.input.tier.06", "Super Bus (I) (LuV)", 6)) .getStackForm(1L)); GregtechItemList.Hatch_SuperBus_Input_ZPM - .set((new GT_MetaTileEntity_SuperBus_Input(aStartID++, "hatch.superbus.input.tier.07", "Super Bus (I) (ZPM)", 7)) + .set(((IMetaTileEntity) generateBus(aGT_MetaTileEntity_SuperBus_Input, aStartID++, "hatch.superbus.input.tier.07", "Super Bus (I) (ZPM)", 7)) .getStackForm(1L)); GregtechItemList.Hatch_SuperBus_Input_UV - .set((new GT_MetaTileEntity_SuperBus_Input(aStartID++, "hatch.superbus.input.tier.08", "Super Bus (I) (UV)", 8)) + .set(((IMetaTileEntity) generateBus(aGT_MetaTileEntity_SuperBus_Input, aStartID++, "hatch.superbus.input.tier.08", "Super Bus (I) (UV)", 8)) .getStackForm(1L)); GregtechItemList.Hatch_SuperBus_Input_MAX - .set((new GT_MetaTileEntity_SuperBus_Input(aStartID++, "hatch.superbus.input.tier.09", "Super Bus (I) (MAX)", 9)) + .set(((IMetaTileEntity) generateBus(aGT_MetaTileEntity_SuperBus_Input, aStartID++, "hatch.superbus.input.tier.09", "Super Bus (I) (MAX)", 9)) .getStackForm(1L)); /* @@ -142,36 +149,70 @@ public class GregtechCustomHatches { */ GregtechItemList.Hatch_SuperBus_Output_ULV - .set((new GT_MetaTileEntity_SuperBus_Output(aStartID++, "hatch.superbus.output.tier.00", "Super Bus (O) (ULV)", 0)) + .set(((IMetaTileEntity) generateBus(aGT_MetaTileEntity_SuperBus_Output, aStartID++, "hatch.superbus.output.tier.00", "Super Bus (O) (ULV)", 0)) .getStackForm(1L)); GregtechItemList.Hatch_SuperBus_Output_LV - .set((new GT_MetaTileEntity_SuperBus_Output(aStartID++, "hatch.superbus.output.tier.01", "Super Bus (O) (LV)", 1)) + .set(((IMetaTileEntity) generateBus(aGT_MetaTileEntity_SuperBus_Output, aStartID++, "hatch.superbus.output.tier.01", "Super Bus (O) (LV)", 1)) .getStackForm(1L)); GregtechItemList.Hatch_SuperBus_Output_MV - .set((new GT_MetaTileEntity_SuperBus_Output(aStartID++, "hatch.superbus.output.tier.02", "Super Bus (O) (MV)", 2)) + .set(((IMetaTileEntity) generateBus(aGT_MetaTileEntity_SuperBus_Output, aStartID++, "hatch.superbus.output.tier.02", "Super Bus (O) (MV)", 2)) .getStackForm(1L)); GregtechItemList.Hatch_SuperBus_Output_HV - .set((new GT_MetaTileEntity_SuperBus_Output(aStartID++, "hatch.superbus.output.tier.03", "Super Bus (O) (HV)", 3)) + .set(((IMetaTileEntity) generateBus(aGT_MetaTileEntity_SuperBus_Output, aStartID++, "hatch.superbus.output.tier.03", "Super Bus (O) (HV)", 3)) .getStackForm(1L)); GregtechItemList.Hatch_SuperBus_Output_EV - .set((new GT_MetaTileEntity_SuperBus_Output(aStartID++, "hatch.superbus.output.tier.04", "Super Bus (O) (EV)", 4)) + .set(((IMetaTileEntity) generateBus(aGT_MetaTileEntity_SuperBus_Output, aStartID++, "hatch.superbus.output.tier.04", "Super Bus (O) (EV)", 4)) .getStackForm(1L)); GregtechItemList.Hatch_SuperBus_Output_IV - .set((new GT_MetaTileEntity_SuperBus_Output(aStartID++, "hatch.superbus.output.tier.05", "Super Bus (O) (IV)", 5)) + .set(((IMetaTileEntity) generateBus(aGT_MetaTileEntity_SuperBus_Output, aStartID++, "hatch.superbus.output.tier.05", "Super Bus (O) (IV)", 5)) .getStackForm(1L)); GregtechItemList.Hatch_SuperBus_Output_LuV - .set((new GT_MetaTileEntity_SuperBus_Output(aStartID++, "hatch.superbus.output.tier.06", "Super Bus (O) (LuV)", 6)) + .set(((IMetaTileEntity) generateBus(aGT_MetaTileEntity_SuperBus_Output, aStartID++, "hatch.superbus.output.tier.06", "Super Bus (O) (LuV)", 6)) .getStackForm(1L)); GregtechItemList.Hatch_SuperBus_Output_ZPM - .set((new GT_MetaTileEntity_SuperBus_Output(aStartID++, "hatch.superbus.output.tier.07", "Super Bus (O) (ZPM)", 7)) + .set(((IMetaTileEntity) generateBus(aGT_MetaTileEntity_SuperBus_Output, aStartID++, "hatch.superbus.output.tier.07", "Super Bus (O) (ZPM)", 7)) .getStackForm(1L)); GregtechItemList.Hatch_SuperBus_Output_UV - .set((new GT_MetaTileEntity_SuperBus_Output(aStartID++, "hatch.superbus.output.tier.08", "Super Bus (O) (UV)", 8)) + .set(((IMetaTileEntity) generateBus(aGT_MetaTileEntity_SuperBus_Output, aStartID++, "hatch.superbus.output.tier.08", "Super Bus (O) (UV)", 8)) .getStackForm(1L)); GregtechItemList.Hatch_SuperBus_Output_MAX - .set((new GT_MetaTileEntity_SuperBus_Output(aStartID++, "hatch.superbus.output.tier.09", "Super Bus (O) (MAX)", 9)) + .set(((IMetaTileEntity) generateBus(aGT_MetaTileEntity_SuperBus_Output, aStartID++, "hatch.superbus.output.tier.09", "Super Bus (O) (MAX)", 9)) .getStackForm(1L)); } + + private static Object generateBus(Class aClass, int aID, String aUnlocalName, String aLocalName, int aTier) { + Class<?> aBusEntity = aClass; + Constructor<?> constructor; + try { + constructor = aBusEntity.getConstructor(int.class, String.class, String.class, int.class, int.class); + if (constructor != null) { + Object aPipe; + try { + aPipe = constructor.newInstance( + aID, aUnlocalName, + aLocalName, + aTier, + (1+ aTier) * 32); + if (aPipe == null) { + //Logger.INFO("Failed to Generate "+aMaterial+" Hexadecuple pipes."); + } + else { + Logger.INFO("Generated "+aLocalName+"."); + return aPipe; + //GT_OreDictUnificator.registerOre("pipeHexadecuple" + aMaterial, aPipe.getStackForm(1L)); + } + } catch (InstantiationException | IllegalAccessException | IllegalArgumentException + | InvocationTargetException e) { + //Logger.INFO("Failed to Generate "+aMaterial+" Hexadecuple pipes. [Ecx]"); + e.printStackTrace(); + } + } + } catch (NoSuchMethodException | SecurityException e1) { + // TODO Auto-generated catch block + e1.printStackTrace(); + } + return null; + } } diff --git a/src/Java/gtPlusPlus/xmod/gregtech/registration/gregtech/GregtechIndustrialTreeFarm.java b/src/Java/gtPlusPlus/xmod/gregtech/registration/gregtech/GregtechIndustrialTreeFarm.java index a4ca83df9c..94e0875563 100644 --- a/src/Java/gtPlusPlus/xmod/gregtech/registration/gregtech/GregtechIndustrialTreeFarm.java +++ b/src/Java/gtPlusPlus/xmod/gregtech/registration/gregtech/GregtechIndustrialTreeFarm.java @@ -20,7 +20,7 @@ public class GregtechIndustrialTreeFarm { private static void run1() { // Industrial Maceration Stack Multiblock GregtechItemList.Industrial_TreeFarm - .set(new GregtechMetaTileEntityTreeFarm(836, "treefarm.controller.tier.single", "Tree Farmer") + .set(new GregtechMetaTileEntityTreeFarm(836, "treefarm.controller.tier.single", "Tree Growth Simulator") .getStackForm(1L)); } |