diff options
Diffstat (limited to 'src/Java/gtPlusPlus')
6 files changed, 479 insertions, 3 deletions
diff --git a/src/Java/gtPlusPlus/GTplusplus.java b/src/Java/gtPlusPlus/GTplusplus.java index 675c100a0a..e61ff15c06 100644 --- a/src/Java/gtPlusPlus/GTplusplus.java +++ b/src/Java/gtPlusPlus/GTplusplus.java @@ -37,6 +37,7 @@ import gtPlusPlus.core.util.reflect.ReflectionUtils; import gtPlusPlus.xmod.gregtech.common.Meta_GT_Proxy; import gtPlusPlus.xmod.gregtech.common.blocks.textures.TexturesGtBlock; import gtPlusPlus.xmod.gregtech.common.blocks.textures.TexturesGtTools; +import gtPlusPlus.xmod.gregtech.common.tileentities.machines.basic.GT_MetaTileEntity_WorldAccelerator; import net.minecraft.launchwrapper.Launch; import net.minecraftforge.common.config.Configuration; @@ -111,6 +112,8 @@ public class GTplusplus implements ActionListener { true, "Diesel egines with different internals, they consume less fuel overall."); CORE.configSwitches.enableMachine_GeothermalEngines = config.getBoolean("enableMachineGeothermalEngines", "gregtech", true, "These may be overpowered, Consult a local geologist."); + CORE.configSwitches.enableMachine_WorldAccelerators = config.getBoolean("enableMachineWorldAccelerators", + "gregtech", true, "These allow boosting Block/TileEntity Tick times [OP]."); // Multi machines CORE.configSwitches.enableMultiblock_AlloyBlastSmelter = config.getBoolean("enableMultiblockAlloyBlastSmelter", @@ -158,6 +161,13 @@ public class GTplusplus implements ActionListener { //Biomes CORE.DARKBIOME_ID = config.getInt("darkbiome_ID", "worldgen", 238, 1, 254, "The biome within the Dark Dimension."); + //Blacklisted Accelerator TileEntities + GT_MetaTileEntity_WorldAccelerator.BlacklistedTileEntiyClassNames = config.getStringList( + "BlacklistedTileEntiyClassNames", "gregtech", + GT_MetaTileEntity_WorldAccelerator.BlacklistedTileEntiyClassNames, + "The Canonical Class-Names of TileEntities that should be ignored by the WorldAccelerator"); + + config.save(); } @@ -169,8 +179,7 @@ public class GTplusplus implements ActionListener { Utils.LOG_WARNING("Processing texture: " + TexturesGtTools.SKOOKUM_CHOOCHER.getTextureFile().getResourcePath()); // Blocks - Utils.LOG_WARNING( - "Processing texture: " + TexturesGtBlock.Casing_Machine_Dimensional.getTextureFile().getResourcePath()); + Utils.LOG_WARNING("Processing texture: " + TexturesGtBlock.Casing_Machine_Dimensional.getTextureFile().getResourcePath()); } // Pre-Init diff --git a/src/Java/gtPlusPlus/core/handler/COMPAT_HANDLER.java b/src/Java/gtPlusPlus/core/handler/COMPAT_HANDLER.java index 1bba89c7a4..769d3f26e9 100644 --- a/src/Java/gtPlusPlus/core/handler/COMPAT_HANDLER.java +++ b/src/Java/gtPlusPlus/core/handler/COMPAT_HANDLER.java @@ -71,6 +71,9 @@ public class COMPAT_HANDLER { GregtechIndustrialTreeFarm.run(); GregtechIndustrialSifter.run(); GregtechSimpleWasher.run(); + + //New Horizons Content + NewHorizonsAccelerator.run(); } } diff --git a/src/Java/gtPlusPlus/core/lib/CORE.java b/src/Java/gtPlusPlus/core/lib/CORE.java index f3ffd3ed61..18d9c808ba 100644 --- a/src/Java/gtPlusPlus/core/lib/CORE.java +++ b/src/Java/gtPlusPlus/core/lib/CORE.java @@ -127,6 +127,7 @@ public class CORE { public static boolean enableMachine_FluidTanks = true; public static boolean enableMachine_RocketEngines = true; public static boolean enableMachine_GeothermalEngines = true; + public static boolean enableMachine_WorldAccelerators = true; public static boolean enableCustom_Pipes = true; public static boolean enableCustom_Cables = true; diff --git a/src/Java/gtPlusPlus/xmod/gregtech/api/enums/GregtechItemList.java b/src/Java/gtPlusPlus/xmod/gregtech/api/enums/GregtechItemList.java index 4b74f48e3b..21bef3a7f2 100644 --- a/src/Java/gtPlusPlus/xmod/gregtech/api/enums/GregtechItemList.java +++ b/src/Java/gtPlusPlus/xmod/gregtech/api/enums/GregtechItemList.java @@ -180,7 +180,19 @@ public enum GregtechItemList implements GregtechItemContainer { Old_Circuit_Board_Basic, Old_Circuit_Board_Advanced, Old_Circuit_Board_Elite, Old_Circuit_Parts_Crystal_Chip_Elite, Old_Circuit_Parts_Crystal_Chip_Master, Old_Circuit_Parts_Advanced, Old_Circuit_Parts_Wiring_Basic, Old_Circuit_Parts_Wiring_Advanced, Old_Circuit_Parts_Wiring_Elite, - Old_Empty_Board_Basic, Old_Empty_Board_Elite, TESTITEM + Old_Empty_Board_Basic, Old_Empty_Board_Elite, + + + //Debug + TESTITEM, + + //Tick Accelerators from GTNH + AcceleratorLV, AcceleratorMV, AcceleratorHV, AcceleratorEV, + AcceleratorIV, AcceleratorLuV, AcceleratorZPM, AcceleratorUV + + + + ; public static final GregtechItemList[] diff --git a/src/Java/gtPlusPlus/xmod/gregtech/common/tileentities/machines/basic/GT_MetaTileEntity_WorldAccelerator.java b/src/Java/gtPlusPlus/xmod/gregtech/common/tileentities/machines/basic/GT_MetaTileEntity_WorldAccelerator.java new file mode 100644 index 0000000000..34568f60bd --- /dev/null +++ b/src/Java/gtPlusPlus/xmod/gregtech/common/tileentities/machines/basic/GT_MetaTileEntity_WorldAccelerator.java @@ -0,0 +1,323 @@ +package gtPlusPlus.xmod.gregtech.common.tileentities.machines.basic; + +import cpw.mods.fml.relauncher.Side; +import cpw.mods.fml.relauncher.SideOnly; +import gregtech.api.enums.Textures; +import gregtech.api.enums.Textures.BlockIcons.CustomIcon; +import gregtech.api.interfaces.ITexture; +import gregtech.api.interfaces.tileentity.IGregTechTileEntity; +import gregtech.api.metatileentity.MetaTileEntity; +import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_TieredMachineBlock; +import gregtech.api.objects.GT_RenderedTexture; +import gtPlusPlus.core.util.Utils; +import gtPlusPlus.core.util.player.PlayerUtils; +import net.minecraft.block.Block; +import net.minecraft.client.renderer.texture.IIconRegister; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.item.ItemStack; +import net.minecraft.nbt.NBTTagCompound; +import net.minecraft.tileentity.TileEntity; +import net.minecraft.world.World; +import net.minecraftforge.common.util.ForgeDirection; + +import java.util.ArrayList; +import java.util.List; +import java.util.Random; + +import static gregtech.api.enums.GT_Values.V; + +public class GT_MetaTileEntity_WorldAccelerator extends GT_MetaTileEntity_TieredMachineBlock { + + public static String[] BlacklistedTileEntiyClassNames; + + private byte mMode = 0; // 0: RandomTicks around 1: TileEntities with range + // 1 + private static CustomIcon _mGTIco_Norm_Idle; + private static CustomIcon _mGTIco_Norm_Active; + private static CustomIcon _mGTIco_TE_Idle; + private static CustomIcon _mGTIco_TE_Active; + private static int[] mAccelerateStatic = { 1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 512, 512, 512, 512, 512, 512 }; + + @Override + public void registerIcons(IIconRegister aBlockIconRegister) { + super.registerIcons(aBlockIconRegister); + _mGTIco_Norm_Idle = new CustomIcon("iconsets/OVERLAY_ACCELERATOR"); + _mGTIco_Norm_Active = new CustomIcon("iconsets/OVERLAY_ACCELERATOR_ACTIVE"); + _mGTIco_TE_Idle = new CustomIcon("iconsets/OVERLAY_ACCELERATOR_TE"); + _mGTIco_TE_Active = new CustomIcon("iconsets/OVERLAY_ACCELERATOR_TE_ACTIVE"); + } + + @SideOnly(Side.CLIENT) + @Override + public void onValueUpdate(byte aValue) { + mMode = aValue; + } + + @Override + public byte getUpdateData() { + return mMode; + } + + public GT_MetaTileEntity_WorldAccelerator(int pID, String pName, String pNameRegional, int pTier) { + super(pID, pName, pNameRegional, pTier, 0, ""); + } + + @Override + public String[] getDescription() { + return new String[] { + String.format("Accelerating things (Radius: %d EU/t: %d Speed Bonus: x%d)", mTier, + getEnergyDemand(mTier, false), mAccelerateStatic[mTier]), + "Use a screwdriver to change mode", "To accelerate TileEntities, this machine has to be adjacent to it", + "This machine accepts up to 8 Amps", "Accelerating TileEntities doubles Energy-Demand" }; + } + + public GT_MetaTileEntity_WorldAccelerator(String pName, int pTier, int pInvSlotCount, String pDescription, + ITexture[][][] pTextures) { + super(pName, pTier, pInvSlotCount, pDescription, pTextures); + } + + @Override + public MetaTileEntity newMetaEntity(IGregTechTileEntity pTileEntity) { + return new GT_MetaTileEntity_WorldAccelerator(mName, mTier, mInventory.length, mDescription, mTextures); + } + + @Override + public ITexture[][][] getTextureSet(ITexture[] pTextures) { + return null; + } + + @Override + public ITexture[] getTexture(IGregTechTileEntity pBaseMetaTileEntity, byte pSide, byte pFacing, byte pColorIndex, + boolean pActive, boolean pRedstone) { + if (mMode == 0) + return new ITexture[] { Textures.BlockIcons.MACHINE_CASINGS[mTier][pColorIndex + 1], + (pSide < 2) ? null + : pActive ? new GT_RenderedTexture(_mGTIco_Norm_Active) + : new GT_RenderedTexture(_mGTIco_Norm_Idle) }; + else + return new ITexture[] { Textures.BlockIcons.MACHINE_CASINGS[mTier][pColorIndex + 1], (pSide < 2) ? null + : pActive ? new GT_RenderedTexture(_mGTIco_TE_Active) : new GT_RenderedTexture(_mGTIco_TE_Idle) }; + } + + @Override + public boolean allowPullStack(IGregTechTileEntity pBaseMetaTileEntity, int pIndex, byte pSide, ItemStack pStack) { + return false; + } + + @Override + public boolean allowPutStack(IGregTechTileEntity pBaseMetaTileEntity, int pIndex, byte pSide, ItemStack pStack) { + return false; + } + + @Override + public void saveNBTData(NBTTagCompound pNBT) { + pNBT.setByte("mAccelMode", mMode); + } + + public static long getEnergyDemand(int pTier, boolean pIsAcceleratingTEs) { + return V[pTier] * (pIsAcceleratingTEs ? 6 : 3); + } + + @Override + public void loadNBTData(NBTTagCompound pNBT) { + mMode = pNBT.getByte("mAccelMode"); + } + + @Override + public boolean isAccessAllowed(EntityPlayer pPlayer) { + return true; + } + + @Override + public boolean isSimpleMachine() { + return false; + } + + @Override + public boolean isFacingValid(byte aFacing) { + return true; + } + + @Override + public boolean isEnetInput() { + return true; + } + + @Override + public boolean isInputFacing(byte aSide) { + return true; + } + + @Override + public boolean isTeleporterCompatible() { + return false; + } + + @Override + public long getMinimumStoredEU() { + return 512; + } + + @Override + public long maxEUStore() { + return 512 + V[mTier] * 50; + } + + @Override + public long maxEUInput() { + return V[mTier]; + } + + @Override + public long maxAmperesIn() { + return 8; + } + + private static String[] mModeStr = { "Blocks", "TileEntities" }; + + @Override + public void onScrewdriverRightClick(byte pSide, EntityPlayer pPlayer, float pX, float pY, float pZ) { + mMode = (byte) (mMode == 0x00 ? 0x01 : 0x00); + markDirty(); + PlayerUtils.messagePlayer(pPlayer, String.format("Switched mode to: %s", mModeStr[mMode])); + } + + @Override + public void onPostTick(IGregTechTileEntity pBaseMetaTileEntity, long pTick) { + try { + if (!pBaseMetaTileEntity.isServerSide()) + return; + + long tEnergyDemand = getEnergyDemand(mTier, (mMode == 1)); + + // Do we have enough energy to run? Or are we not allowed to run? + if (pBaseMetaTileEntity.getStoredEU() < tEnergyDemand || !pBaseMetaTileEntity.isAllowedToWork()) { + // Check if machine was active before + if (pBaseMetaTileEntity.isActive()) + pBaseMetaTileEntity.setActive(false); // Then disable it now + } else { + // Continue to drain power + if (pBaseMetaTileEntity.decreaseStoredEnergyUnits(tEnergyDemand, false)) { + World tWorld = pBaseMetaTileEntity.getWorld(); + // Limit the random ticks to once per second + if (mMode == 0) { + if (pTick % 20 == 0) + doAccelerateNormalBlocks(pBaseMetaTileEntity, tWorld); + } else + doAccelerateTileEntities(pBaseMetaTileEntity, tWorld); + + } else { + // Energy drain failed. Disable machine + if (pBaseMetaTileEntity.isActive()) + pBaseMetaTileEntity.setActive(false); + } + } + } catch (Exception e) { + Utils.LOG_ERROR("GT_MetaTileEntity_WorldAccelerator.onPostTick.crash"); + Utils.LOG_ERROR(e.getMessage()); + } + } + + private void doAccelerateTileEntities(IGregTechTileEntity pBaseMetaTileEntity, World pWorld) { + try { + if (!pBaseMetaTileEntity.isActive()) + getBaseMetaTileEntity().setActive(true); + + for (ForgeDirection tDir : ForgeDirection.VALID_DIRECTIONS) { + TileEntity tTile = pBaseMetaTileEntity.getTileEntityAtSide((byte) tDir.ordinal()); + if (isTEBlackListed(tTile)) + continue; + + long tMaxTime = System.nanoTime() + 1000000; + for (int j = 0; j < mAccelerateStatic[mTier]; j++) { + tTile.updateEntity(); + if (System.nanoTime() > tMaxTime) + break; + } + } + } catch (Exception e) { + Utils.LOG_ERROR("GT_MetaTileEntity_WorldAccelerator.doAccelerateTileEntities.crash"); + Utils.LOG_ERROR(e.getMessage()); + } + } + + private static List<String> _mBlacklistedTileEntities = new ArrayList<String>(); + + // Inspired by ChromatiCraft's TileAccelerator + private boolean isTEBlackListed(TileEntity pTile) { + if (pTile == null) + return true; // Obvious + if (!pTile.canUpdate()) + return true; // Skip if TE can't update at all + if (pTile.isInvalid()) + return true; // Obvious + + String tSimpleClassName = pTile.getClass().getSimpleName().toLowerCase(); + String tCanonicalName = pTile.getClass().getCanonicalName().toLowerCase(); + if (tSimpleClassName.contains("conduit") || tSimpleClassName.contains("wire") + || tSimpleClassName.contains("cable")) + return true; + if (tCanonicalName.contains("appeng") || tCanonicalName.contains("gregtech")) + // Don't accelerate ANY Gregtech machines! + return true; + for (String tS : BlacklistedTileEntiyClassNames) { + if (tCanonicalName.equalsIgnoreCase(tS)) + return true; + } + + return false; + } + + /** + * Accelerate normal blocks. Eats some power and adds randomTicks to every + * block within its working area (Tier-Number = radius) This does only + * affect blocks that implement the "RandomTick" method; Which is mostly + * used for grass growth and plants. + * + * @param pBaseMetaTileEntity + */ + private void doAccelerateNormalBlocks(IGregTechTileEntity pBaseMetaTileEntity, World pWorld) { + if (!pBaseMetaTileEntity.isActive()) + getBaseMetaTileEntity().setActive(true); + + Random rnd = new Random(); + int tX = pBaseMetaTileEntity.getXCoord(); + int tY = pBaseMetaTileEntity.getYCoord(); + int tZ = pBaseMetaTileEntity.getZCoord(); + + int tX1 = tX - mTier; + int tX2 = tX + mTier; + int tY1 = Math.max(tY - mTier, 0); // Limit to bedrock + int tY2 = Math.min(tY + mTier, 255); // Limit to build height + int tZ1 = tZ - mTier; + int tZ2 = tZ + mTier; + + for (int xi = tX1; xi <= tX2; xi++) + for (int yi = tY1; yi <= tY2; yi++) + for (int zi = tZ1; zi <= tZ2; zi++) + tryTickBlock(pWorld, xi, yi, zi, rnd); + + } + + /** + * Send a tick to the target block + * + * @param pWorld + * @param pX + * @param pY + * @param pZ + * @param pRnd + */ + private void tryTickBlock(World pWorld, int pX, int pY, int pZ, Random pRnd) { + try { + for (int j = 0; j < mTier; j++) { + Block tBlock = pWorld.getBlock(pX, pY, pZ); + if (tBlock.getTickRandomly()) + tBlock.updateTick(pWorld, pX, pY, pZ, pRnd); + } + } catch (Exception e) { + Utils.LOG_ERROR("GT_MetaTileEntity_WorldAccelerator.tryTickBlock.crash"); + Utils.LOG_ERROR(e.getMessage()); + } + } +}
\ No newline at end of file diff --git a/src/Java/gtPlusPlus/xmod/gregtech/registration/gregtech/NewHorizonsAccelerator.java b/src/Java/gtPlusPlus/xmod/gregtech/registration/gregtech/NewHorizonsAccelerator.java new file mode 100644 index 0000000000..c2c2fd593d --- /dev/null +++ b/src/Java/gtPlusPlus/xmod/gregtech/registration/gregtech/NewHorizonsAccelerator.java @@ -0,0 +1,128 @@ +package gtPlusPlus.xmod.gregtech.registration.gregtech; + +import gregtech.api.enums.*; +import gregtech.api.util.GT_ModHandler; +import gtPlusPlus.core.lib.CORE; +import gtPlusPlus.core.lib.LoadedMods; +import gtPlusPlus.core.material.ALLOY; +import gtPlusPlus.core.recipe.common.CI; +import gtPlusPlus.core.util.Utils; +import gtPlusPlus.xmod.gregtech.api.enums.GregtechItemList; +import gtPlusPlus.xmod.gregtech.common.tileentities.generators.GregtechMetaTileEntityGeothermalGenerator; +import gtPlusPlus.xmod.gregtech.common.tileentities.machines.basic.GT_MetaTileEntity_WorldAccelerator; +import net.minecraft.item.ItemStack; + +public class NewHorizonsAccelerator { + + public static void run() + { + if (LoadedMods.Gregtech && !CORE.GTNH){ + Utils.LOG_INFO("New Horizons Content | Registering World Accelerators."); + if (CORE.configSwitches.enableMachine_WorldAccelerators) { + run1(); + } + } + + } + + private static void run1(){ + GregtechItemList.AcceleratorLV.set(new GT_MetaTileEntity_WorldAccelerator( + 11100, "basicmachine.accelerator.tier.01", "Basic World Accelerator", 1).getStackForm(1L)); + GregtechItemList.AcceleratorMV.set(new GT_MetaTileEntity_WorldAccelerator( + 11101, "basicmachine.accelerator.tier.02", "Advanced World Accelerator", 2).getStackForm(1L)); + GregtechItemList.AcceleratorHV.set(new GT_MetaTileEntity_WorldAccelerator( + 11102, "basicmachine.accelerator.tier.03", "Advanced World Accelerator II", 3).getStackForm(1L)); + GregtechItemList.AcceleratorEV.set(new GT_MetaTileEntity_WorldAccelerator( + 11103, "basicmachine.accelerator.tier.04", "Advanced World Accelerator III", 4).getStackForm(1L)); + GregtechItemList.AcceleratorIV.set(new GT_MetaTileEntity_WorldAccelerator( + 11104, "basicmachine.accelerator.tier.05", "Advanced World Accelerator IV", 5).getStackForm(1L)); + GregtechItemList.AcceleratorLuV.set(new GT_MetaTileEntity_WorldAccelerator( + 11105, "basicmachine.accelerator.tier.06", "Elite World Accelerator", 6).getStackForm(1L)); + GregtechItemList.AcceleratorZPM.set(new GT_MetaTileEntity_WorldAccelerator( + 11106, "basicmachine.accelerator.tier.07", "Elite World Accelerator II", 7).getStackForm(1L)); + GregtechItemList.AcceleratorUV.set(new GT_MetaTileEntity_WorldAccelerator( + 11107, "basicmachine.accelerator.tier.08", "Ultimate Time Anomaly", 8).getStackForm(1L)); + + + GT_ModHandler.addCraftingRecipe(GregtechItemList.AcceleratorLV.get(1L), + GT_ModHandler.RecipeBits.DISMANTLEABLE | GT_ModHandler.RecipeBits.NOT_REMOVABLE | GT_ModHandler.RecipeBits.REVERSIBLE | GT_ModHandler.RecipeBits.BUFFERED, + new Object[]{"RMR", "PBC", "IMI", + 'R', ItemList.Robot_Arm_LV, + 'M', ItemList.Electric_Motor_LV, + 'P', ItemList.Electric_Pump_LV, + 'B', ItemList.Hull_LV, + 'C', ItemList.Conveyor_Module_LV, + 'I', ItemList.Electric_Piston_LV}); + + GT_ModHandler.addCraftingRecipe(GregtechItemList.AcceleratorMV.get(1L), + GT_ModHandler.RecipeBits.DISMANTLEABLE | GT_ModHandler.RecipeBits.NOT_REMOVABLE | GT_ModHandler.RecipeBits.REVERSIBLE | GT_ModHandler.RecipeBits.BUFFERED, + new Object[]{"RMR", "PBC", "IMI", + 'R', ItemList.Robot_Arm_MV, + 'M', ItemList.Electric_Motor_MV, + 'P', ItemList.Electric_Pump_MV, + 'B', ItemList.Hull_MV, + 'C', ItemList.Conveyor_Module_MV, + 'I', ItemList.Electric_Piston_MV}); + + GT_ModHandler.addCraftingRecipe(GregtechItemList.AcceleratorHV.get(1L), + GT_ModHandler.RecipeBits.DISMANTLEABLE | GT_ModHandler.RecipeBits.NOT_REMOVABLE | GT_ModHandler.RecipeBits.REVERSIBLE | GT_ModHandler.RecipeBits.BUFFERED, + new Object[]{"RMR", "PBC", "IMI", + 'R', ItemList.Robot_Arm_HV, + 'M', ItemList.Electric_Motor_HV, + 'P', ItemList.Electric_Pump_HV, + 'B', ItemList.Hull_HV, + 'C', ItemList.Conveyor_Module_HV, + 'I', ItemList.Electric_Piston_HV}); + + GT_ModHandler.addCraftingRecipe(GregtechItemList.AcceleratorEV.get(1L), + GT_ModHandler.RecipeBits.DISMANTLEABLE | GT_ModHandler.RecipeBits.NOT_REMOVABLE | GT_ModHandler.RecipeBits.REVERSIBLE | GT_ModHandler.RecipeBits.BUFFERED, + new Object[]{"RMR", "PBC", "IMI", + 'R', ItemList.Robot_Arm_EV, + 'M', ItemList.Electric_Motor_EV, + 'P', ItemList.Electric_Pump_EV, + 'B', ItemList.Hull_EV, + 'C', ItemList.Conveyor_Module_EV, + 'I', ItemList.Electric_Piston_EV}); + + GT_ModHandler.addCraftingRecipe(GregtechItemList.AcceleratorIV.get(1L), + GT_ModHandler.RecipeBits.DISMANTLEABLE | GT_ModHandler.RecipeBits.NOT_REMOVABLE | GT_ModHandler.RecipeBits.REVERSIBLE | GT_ModHandler.RecipeBits.BUFFERED, + new Object[]{"RMR", "PBC", "IMI", + 'R', ItemList.Robot_Arm_IV, + 'M', ItemList.Electric_Motor_IV, + 'P', ItemList.Electric_Pump_IV, + 'B', ItemList.Hull_IV, + 'C', ItemList.Conveyor_Module_IV, + 'I', ItemList.Electric_Piston_IV}); + + GT_ModHandler.addCraftingRecipe(GregtechItemList.AcceleratorLuV.get(1L), + GT_ModHandler.RecipeBits.DISMANTLEABLE | GT_ModHandler.RecipeBits.NOT_REMOVABLE | GT_ModHandler.RecipeBits.REVERSIBLE | GT_ModHandler.RecipeBits.BUFFERED, + new Object[]{"RMR", "PBC", "IMI", + 'R', ItemList.Robot_Arm_LuV, + 'M', ItemList.Electric_Motor_LuV, + 'P', ItemList.Electric_Pump_LuV, + 'B', ItemList.Hull_LuV, + 'C', ItemList.Conveyor_Module_LuV, + 'I', ItemList.Electric_Piston_LuV}); + + GT_ModHandler.addCraftingRecipe(GregtechItemList.AcceleratorZPM.get(1L), + GT_ModHandler.RecipeBits.DISMANTLEABLE | GT_ModHandler.RecipeBits.NOT_REMOVABLE | GT_ModHandler.RecipeBits.REVERSIBLE | GT_ModHandler.RecipeBits.BUFFERED, + new Object[]{"RMR", "PBC", "IMI", + 'R', ItemList.Robot_Arm_ZPM, + 'M', ItemList.Electric_Motor_ZPM, + 'P', ItemList.Electric_Pump_ZPM, + 'B', ItemList.Hull_ZPM, + 'C', ItemList.Conveyor_Module_ZPM, + 'I', ItemList.Electric_Piston_ZPM}); + + GT_ModHandler.addCraftingRecipe(GregtechItemList.AcceleratorUV.get(1L), + GT_ModHandler.RecipeBits.DISMANTLEABLE | GT_ModHandler.RecipeBits.NOT_REMOVABLE | GT_ModHandler.RecipeBits.REVERSIBLE | GT_ModHandler.RecipeBits.BUFFERED, + new Object[]{"RMR", "PBC", "IMI", + 'R', ItemList.Robot_Arm_UV, + 'M', ItemList.Electric_Motor_UV, + 'P', ItemList.Electric_Pump_UV, + 'B', ItemList.Hull_UV, + 'C', ItemList.Conveyor_Module_UV, + 'I', ItemList.Electric_Piston_UV}); + } + +} |