From b33cfd02d8a367af0ba9a6689a0507440f44d07c Mon Sep 17 00:00:00 2001 From: Draknyte1 Date: Fri, 22 Apr 2016 17:59:17 +1000 Subject: Refactoring like a champion. --- .../gregtech/api/energy/IC2ElectricItem.java | 55 +++ .../api/energy/IC2ElectricItemManager.java | 95 +++++ .../gregtech/api/enums/AddExtraOreDict.java | 13 + .../gregtech/api/enums/ExtraOreDictNames.java | 18 + .../gregtech/api/enums/GregtechItemList.java | 171 ++++++++ .../gregtech/api/enums/GregtechTextures.java | 127 ++++++ .../api/gui/CONTAINER_IronBlastFurnace.java | 31 ++ .../gregtech/api/gui/CONTAINER_SafeBlock.java | 120 ++++++ .../gregtech/api/gui/CONTAINER_SteamCondenser.java | 97 +++++ .../gregtech/api/gui/GUI_IronBlastFurnace.java | 30 ++ .../miscutil/gregtech/api/gui/GUI_SafeBlock.java | 49 +++ .../gregtech/api/gui/GUI_SteamCondenser.java | 55 +++ .../miscutil/gregtech/api/init/InitGregtech.java | 31 ++ .../api/init/machines/GregtechCobbleGenerator.java | 51 +++ .../api/init/machines/GregtechConduits.java | 103 +++++ .../api/init/machines/GregtechEnergyBuffer.java | 83 ++++ .../machines/GregtechIndustrialCentrifuge.java | 27 ++ .../api/init/machines/GregtechSafeBlock.java | 53 +++ .../api/init/machines/GregtechSteamCondenser.java | 36 ++ .../api/interfaces/GregtechItemContainer.java | 24 ++ .../implementations/GregtechMetaCasingBlocks.java | 88 ++++ .../implementations/GregtechMetaCondensor.java | 164 ++++++++ .../GregtechMetaCreativeEnergyBuffer.java | 261 ++++++++++++ .../implementations/GregtechMetaEnergyBuffer.java | 446 +++++++++++++++++++++ .../GregtechMetaPipeEntity_Cable.java | 235 +++++++++++ .../implementations/GregtechMetaSafeBlock.java | 76 ++++ .../GregtechMetaTileEntityIronBlastFurnace.java | 369 +++++++++++++++++ .../base/GregtechMetaBoilerBase.java | 328 +++++++++++++++ .../base/GregtechMetaSafeBlockBase.java | 343 ++++++++++++++++ .../base/GregtechMetaTileEntity.java | 67 ++++ .../implementations/base/GregtechSteelBoiler.java | 290 ++++++++++++++ src/Java/miscutil/gregtech/api/util/IMessage.java | 21 + .../api/util/VanillaChatCommandSender.java | 35 ++ ...T_MetaTileEntity_LargeIndustrialCentrifuge.java | 198 +++++++++ .../miscutil/gregtech/energy/IC2ElectricItem.java | 55 --- .../gregtech/energy/IC2ElectricItemManager.java | 95 ----- .../miscutil/gregtech/enums/AddExtraOreDict.java | 13 - .../miscutil/gregtech/enums/ExtraOreDictNames.java | 18 - .../miscutil/gregtech/enums/GregtechItemList.java | 168 -------- .../gregtech/gui/CONTAINER_IronBlastFurnace.java | 31 -- .../miscutil/gregtech/gui/CONTAINER_SafeBlock.java | 120 ------ .../gregtech/gui/CONTAINER_SteamCondenser.java | 97 ----- .../gregtech/gui/GUI_IronBlastFurnace.java | 30 -- src/Java/miscutil/gregtech/gui/GUI_SafeBlock.java | 49 --- .../miscutil/gregtech/gui/GUI_SteamCondenser.java | 55 --- src/Java/miscutil/gregtech/init/InitGregtech.java | 31 -- .../init/machines/GregtechCobbleGenerator.java | 51 --- .../gregtech/init/machines/GregtechConduits.java | 103 ----- .../init/machines/GregtechEnergyBuffer.java | 83 ---- .../gregtech/init/machines/GregtechSafeBlock.java | 53 --- .../init/machines/GregtechSteamCondenser.java | 36 -- .../gregtech/interfaces/GregtechItemContainer.java | 24 -- .../implementations/GregtechMetaCasingBlocks.java | 87 ---- .../implementations/GregtechMetaCondensor.java | 164 -------- .../GregtechMetaCreativeEnergyBuffer.java | 261 ------------ .../implementations/GregtechMetaEnergyBuffer.java | 446 --------------------- .../GregtechMetaPipeEntity_Cable.java | 235 ----------- .../implementations/GregtechMetaSafeBlock.java | 76 ---- .../GregtechMetaTileEntityIronBlastFurnace.java | 369 ----------------- .../base/GregtechMetaBoilerBase.java | 328 --------------- .../base/GregtechMetaSafeBlockBase.java | 343 ---------------- .../base/GregtechMetaTileEntity.java | 67 ---- .../implementations/base/GregtechSteelBoiler.java | 290 -------------- src/Java/miscutil/gregtech/util/IMessage.java | 21 - .../gregtech/util/VanillaChatCommandSender.java | 35 -- 65 files changed, 4190 insertions(+), 3834 deletions(-) create mode 100644 src/Java/miscutil/gregtech/api/energy/IC2ElectricItem.java create mode 100644 src/Java/miscutil/gregtech/api/energy/IC2ElectricItemManager.java create mode 100644 src/Java/miscutil/gregtech/api/enums/AddExtraOreDict.java create mode 100644 src/Java/miscutil/gregtech/api/enums/ExtraOreDictNames.java create mode 100644 src/Java/miscutil/gregtech/api/enums/GregtechItemList.java create mode 100644 src/Java/miscutil/gregtech/api/enums/GregtechTextures.java create mode 100644 src/Java/miscutil/gregtech/api/gui/CONTAINER_IronBlastFurnace.java create mode 100644 src/Java/miscutil/gregtech/api/gui/CONTAINER_SafeBlock.java create mode 100644 src/Java/miscutil/gregtech/api/gui/CONTAINER_SteamCondenser.java create mode 100644 src/Java/miscutil/gregtech/api/gui/GUI_IronBlastFurnace.java create mode 100644 src/Java/miscutil/gregtech/api/gui/GUI_SafeBlock.java create mode 100644 src/Java/miscutil/gregtech/api/gui/GUI_SteamCondenser.java create mode 100644 src/Java/miscutil/gregtech/api/init/InitGregtech.java create mode 100644 src/Java/miscutil/gregtech/api/init/machines/GregtechCobbleGenerator.java create mode 100644 src/Java/miscutil/gregtech/api/init/machines/GregtechConduits.java create mode 100644 src/Java/miscutil/gregtech/api/init/machines/GregtechEnergyBuffer.java create mode 100644 src/Java/miscutil/gregtech/api/init/machines/GregtechIndustrialCentrifuge.java create mode 100644 src/Java/miscutil/gregtech/api/init/machines/GregtechSafeBlock.java create mode 100644 src/Java/miscutil/gregtech/api/init/machines/GregtechSteamCondenser.java create mode 100644 src/Java/miscutil/gregtech/api/interfaces/GregtechItemContainer.java create mode 100644 src/Java/miscutil/gregtech/api/metatileentity/implementations/GregtechMetaCasingBlocks.java create mode 100644 src/Java/miscutil/gregtech/api/metatileentity/implementations/GregtechMetaCondensor.java create mode 100644 src/Java/miscutil/gregtech/api/metatileentity/implementations/GregtechMetaCreativeEnergyBuffer.java create mode 100644 src/Java/miscutil/gregtech/api/metatileentity/implementations/GregtechMetaEnergyBuffer.java create mode 100644 src/Java/miscutil/gregtech/api/metatileentity/implementations/GregtechMetaPipeEntity_Cable.java create mode 100644 src/Java/miscutil/gregtech/api/metatileentity/implementations/GregtechMetaSafeBlock.java create mode 100644 src/Java/miscutil/gregtech/api/metatileentity/implementations/GregtechMetaTileEntityIronBlastFurnace.java create mode 100644 src/Java/miscutil/gregtech/api/metatileentity/implementations/base/GregtechMetaBoilerBase.java create mode 100644 src/Java/miscutil/gregtech/api/metatileentity/implementations/base/GregtechMetaSafeBlockBase.java create mode 100644 src/Java/miscutil/gregtech/api/metatileentity/implementations/base/GregtechMetaTileEntity.java create mode 100644 src/Java/miscutil/gregtech/api/metatileentity/implementations/base/GregtechSteelBoiler.java create mode 100644 src/Java/miscutil/gregtech/api/util/IMessage.java create mode 100644 src/Java/miscutil/gregtech/api/util/VanillaChatCommandSender.java create mode 100644 src/Java/miscutil/gregtech/common/machines/multi/GT_MetaTileEntity_LargeIndustrialCentrifuge.java delete mode 100644 src/Java/miscutil/gregtech/energy/IC2ElectricItem.java delete mode 100644 src/Java/miscutil/gregtech/energy/IC2ElectricItemManager.java delete mode 100644 src/Java/miscutil/gregtech/enums/AddExtraOreDict.java delete mode 100644 src/Java/miscutil/gregtech/enums/ExtraOreDictNames.java delete mode 100644 src/Java/miscutil/gregtech/enums/GregtechItemList.java delete mode 100644 src/Java/miscutil/gregtech/gui/CONTAINER_IronBlastFurnace.java delete mode 100644 src/Java/miscutil/gregtech/gui/CONTAINER_SafeBlock.java delete mode 100644 src/Java/miscutil/gregtech/gui/CONTAINER_SteamCondenser.java delete mode 100644 src/Java/miscutil/gregtech/gui/GUI_IronBlastFurnace.java delete mode 100644 src/Java/miscutil/gregtech/gui/GUI_SafeBlock.java delete mode 100644 src/Java/miscutil/gregtech/gui/GUI_SteamCondenser.java delete mode 100644 src/Java/miscutil/gregtech/init/InitGregtech.java delete mode 100644 src/Java/miscutil/gregtech/init/machines/GregtechCobbleGenerator.java delete mode 100644 src/Java/miscutil/gregtech/init/machines/GregtechConduits.java delete mode 100644 src/Java/miscutil/gregtech/init/machines/GregtechEnergyBuffer.java delete mode 100644 src/Java/miscutil/gregtech/init/machines/GregtechSafeBlock.java delete mode 100644 src/Java/miscutil/gregtech/init/machines/GregtechSteamCondenser.java delete mode 100644 src/Java/miscutil/gregtech/interfaces/GregtechItemContainer.java delete mode 100644 src/Java/miscutil/gregtech/metatileentity/implementations/GregtechMetaCasingBlocks.java delete mode 100644 src/Java/miscutil/gregtech/metatileentity/implementations/GregtechMetaCondensor.java delete mode 100644 src/Java/miscutil/gregtech/metatileentity/implementations/GregtechMetaCreativeEnergyBuffer.java delete mode 100644 src/Java/miscutil/gregtech/metatileentity/implementations/GregtechMetaEnergyBuffer.java delete mode 100644 src/Java/miscutil/gregtech/metatileentity/implementations/GregtechMetaPipeEntity_Cable.java delete mode 100644 src/Java/miscutil/gregtech/metatileentity/implementations/GregtechMetaSafeBlock.java delete mode 100644 src/Java/miscutil/gregtech/metatileentity/implementations/GregtechMetaTileEntityIronBlastFurnace.java delete mode 100644 src/Java/miscutil/gregtech/metatileentity/implementations/base/GregtechMetaBoilerBase.java delete mode 100644 src/Java/miscutil/gregtech/metatileentity/implementations/base/GregtechMetaSafeBlockBase.java delete mode 100644 src/Java/miscutil/gregtech/metatileentity/implementations/base/GregtechMetaTileEntity.java delete mode 100644 src/Java/miscutil/gregtech/metatileentity/implementations/base/GregtechSteelBoiler.java delete mode 100644 src/Java/miscutil/gregtech/util/IMessage.java delete mode 100644 src/Java/miscutil/gregtech/util/VanillaChatCommandSender.java (limited to 'src/Java/miscutil/gregtech') diff --git a/src/Java/miscutil/gregtech/api/energy/IC2ElectricItem.java b/src/Java/miscutil/gregtech/api/energy/IC2ElectricItem.java new file mode 100644 index 0000000000..eae47b9910 --- /dev/null +++ b/src/Java/miscutil/gregtech/api/energy/IC2ElectricItem.java @@ -0,0 +1,55 @@ +package miscutil.gregtech.api.energy; + +import net.minecraft.item.Item; +import net.minecraft.item.ItemStack; + +/** + * Provides the ability to store energy on the implementing item. + * + * The item should have a maximum damage of 13. + */ +public interface IC2ElectricItem { + /** + * Determine if the item can be used in a machine or as an armor part to supply energy. + * + * @return Whether the item can supply energy + */ + boolean canProvideEnergy(ItemStack itemStack); + + /** + * Get the item ID to use for a charge energy greater than 0. + * + * @return Item ID to use + */ + Item getChargedItem(ItemStack itemStack); + + /** + * Get the item ID to use for a charge energy of 0. + * + * @return Item ID to use + */ + Item getEmptyItem(ItemStack itemStack); + + /** + * Get the item's maximum charge energy in EU. + * + * @return Maximum charge energy + */ + double getMaxCharge(ItemStack itemStack); + + /** + * Get the item's tier, lower tiers can't send energy to higher ones. + * Batteries are Tier 1, Energy Crystals are Tier 2, Lapotron Crystals are Tier 3. + * + * @return Item's tier + */ + int getTier(ItemStack itemStack); + + /** + * Get the item's transfer limit in EU per transfer operation. + * + * @return Transfer limit + */ + double getTransferLimit(ItemStack itemStack); +} + diff --git a/src/Java/miscutil/gregtech/api/energy/IC2ElectricItemManager.java b/src/Java/miscutil/gregtech/api/energy/IC2ElectricItemManager.java new file mode 100644 index 0000000000..4b2fcb2fec --- /dev/null +++ b/src/Java/miscutil/gregtech/api/energy/IC2ElectricItemManager.java @@ -0,0 +1,95 @@ +package miscutil.gregtech.api.energy; + +import net.minecraft.entity.EntityLivingBase; +import net.minecraft.item.ItemStack; + +/** + * This interface specifies a manager to handle the various tasks for electric items. + * + * The default implementation does the following: + * - store and retrieve the charge + * - handle charging, taking amount, tier, transfer limit, canProvideEnergy and simulate into account + * - replace item IDs if appropriate (getChargedItemId() and getEmptyItemId()) + * - update and manage the damage value for the visual charge indicator + * + * @note If you're implementing your own variant (ISpecialElectricItem), you can delegate to the + * default implementations through ElectricItem.rawManager. The default implementation is designed + * to minimize its dependency on its own constraints/structure and delegates most work back to the + * more atomic features in the gateway manager. + */ +public interface IC2ElectricItemManager { + /** + * Charge an item with a specified amount of energy. + * + * @param itemStack electric item's stack + * @param amount amount of energy to charge in EU + * @param tier tier of the charging device, has to be at least as high as the item to charge + * @param ignoreTransferLimit ignore the transfer limit specified by getTransferLimit() + * @param simulate don't actually change the item, just determine the return value + * @return Energy transferred into the electric item + */ + double charge(ItemStack stack, double amount, int tier, boolean ignoreTransferLimit, boolean simulate); + + /** + * Discharge an item by a specified amount of energy + * + * @param itemStack electric item's stack + * @param amount amount of energy to discharge in EU + * @param tier tier of the discharging device, has to be at least as high as the item to discharge + * @param ignoreTransferLimit ignore the transfer limit specified by getTransferLimit() + * @param externally use the supplied item externally, i.e. to power something else as if it was a battery + * @param simulate don't actually discharge the item, just determine the return value + * @return Energy retrieved from the electric item + */ + double discharge(ItemStack stack, double amount, int tier, boolean ignoreTransferLimit, boolean externally, boolean simulate); + + /** + * Determine the charge level for the specified item. + * + * @param itemStack ItemStack containing the electric item + * @return charge level in EU + */ + double getCharge(ItemStack stack); + + /** + * Determine if the specified electric item has at least a specific amount of EU. + * This is supposed to be used in the item code during operation, for example if you want to implement your own electric item. + * BatPacks are not taken into account. + * + * @param itemStack electric item's stack + * @param amount minimum amount of energy required + * @return true if there's enough energy + */ + boolean canUse(ItemStack stack, double amount); + + /** + * Try to retrieve a specific amount of energy from an Item, and if applicable, a BatPack. + * This is supposed to be used in the item code during operation, for example if you want to implement your own electric item. + * + * @param itemStack electric item's stack + * @param amount amount of energy to discharge in EU + * @param entity entity holding the item + * @return true if the operation succeeded + */ + boolean use(ItemStack stack, double amount, EntityLivingBase entity); + + /** + * Charge an item from the BatPack a player is wearing. + * This is supposed to be used in the item code during operation, for example if you want to implement your own electric item. + * use() already contains this functionality. + * + * @param itemStack electric item's stack + * @param entity entity holding the item + */ + void chargeFromArmor(ItemStack stack, EntityLivingBase entity); + + /** + * Get the tool tip to display for electric items. + * + * @param itemStack ItemStack to determine the tooltip for + * @return tool tip string or null for none + */ + String getToolTip(ItemStack stack); + + // TODO: add tier getter +} diff --git a/src/Java/miscutil/gregtech/api/enums/AddExtraOreDict.java b/src/Java/miscutil/gregtech/api/enums/AddExtraOreDict.java new file mode 100644 index 0000000000..dff0483470 --- /dev/null +++ b/src/Java/miscutil/gregtech/api/enums/AddExtraOreDict.java @@ -0,0 +1,13 @@ +package miscutil.gregtech.api.enums; + +import gregtech.loaders.preload.GT_Loader_OreDictionary; + +public class AddExtraOreDict extends GT_Loader_OreDictionary { + + @Override + public void run() + { + //GT_OreDictUnificator.registerOre(ExtraOreDictNames.buffer_core, new ItemStack(GregtechEnergyBuffer.itemBufferCore)); + } + +} diff --git a/src/Java/miscutil/gregtech/api/enums/ExtraOreDictNames.java b/src/Java/miscutil/gregtech/api/enums/ExtraOreDictNames.java new file mode 100644 index 0000000000..8ca492c9dd --- /dev/null +++ b/src/Java/miscutil/gregtech/api/enums/ExtraOreDictNames.java @@ -0,0 +1,18 @@ +package miscutil.gregtech.api.enums; + +/** + * + * + * @author Jordan + *Adds in extra names for items (No idea yet why anyone does this in such a fashion..) + */ +public enum ExtraOreDictNames { + buffer_core, itemGregConduit; + +public String unlocalisedName; + +private void ModObject() { + unlocalisedName = name(); +} + +} \ No newline at end of file diff --git a/src/Java/miscutil/gregtech/api/enums/GregtechItemList.java b/src/Java/miscutil/gregtech/api/enums/GregtechItemList.java new file mode 100644 index 0000000000..1a95d49441 --- /dev/null +++ b/src/Java/miscutil/gregtech/api/enums/GregtechItemList.java @@ -0,0 +1,171 @@ +package miscutil.gregtech.api.enums; + +import static gregtech.api.enums.GT_Values.W; +import gregtech.api.util.GT_ModHandler; +import gregtech.api.util.GT_OreDictUnificator; +import gregtech.api.util.GT_Utility; +import miscutil.gregtech.api.interfaces.GregtechItemContainer; +import net.minecraft.block.Block; +import net.minecraft.item.Item; +import net.minecraft.item.ItemStack; +import net.minecraftforge.fluids.Fluid; + +/** + * Class containing all non-OreDict Items of GregTech. + */ +public enum GregtechItemList implements GregtechItemContainer { + + Credit_Copper, + Credit_Iron, + Credit_Silver, + Credit_Gold, + Credit_Platinum, + Credit_Osmium, + Credit_Greg_Copper, + Credit_Greg_Cupronickel, + Credit_Greg_Silver, + Credit_Greg_Gold, + Credit_Greg_Platinum, + Credit_Greg_Osmium, + Credit_Greg_Naquadah, + Energy_Buffer_CREATIVE, + + //Energy Buffers + Energy_Buffer_1by1_ULV, Energy_Buffer_1by1_LV, Energy_Buffer_1by1_MV, Energy_Buffer_1by1_HV, Energy_Buffer_1by1_EV, Energy_Buffer_1by1_IV, Energy_Buffer_1by1_LuV, Energy_Buffer_1by1_ZPM, Energy_Buffer_1by1_UV, Energy_Buffer_1by1_MAX, + + //Cobble Generators + Cobble_Generator_ULV, Cobble_Generator_LV, Cobble_Generator_MV, Cobble_Generator_HV, Cobble_Generator_EV, Cobble_Generator_IV, Cobble_Generator_LuV, Cobble_Generator_ZPM, Cobble_Generator_UV, Cobble_Generator_MAX, + + //The max Steam condenser + Condensor_MAX, + + //Player owned Safes + GT_Safe_ULV, GT_Safe_LV, GT_Safe_MV, GT_Safe_HV, GT_Safe_EV, GT_Safe_IV, GT_Safe_LuV, GT_Safe_ZPM, GT_Safe_UV, GT_Safe_MAX, + + //IronBlastFurnace Machine_Bronze_BlastFurnace + Machine_Iron_BlastFurnace, Casing_IronPlatedBricks, + + //Machine Casings + Casing_Shielding, Casing_Centrifuge1, Casing_Centrifuge2, + + //Large Centrifuge + Industrial_Centrifuge; + + public static final GregtechItemList[] + DYE_ONLY_ITEMS = { + Energy_Buffer_1by1_EV, Energy_Buffer_1by1_EV }; + private ItemStack mStack; + private boolean mHasNotBeenSet = true; + + public static Fluid sOilExtraHeavy, sOilHeavy, sOilMedium, sOilLight, sNaturalGas; + + @Override + public GregtechItemList set(Item aItem) { + mHasNotBeenSet = false; + if (aItem == null) return this; + ItemStack aStack = new ItemStack(aItem, 1, 0); + mStack = GT_Utility.copyAmount(1, aStack); + return this; + } + + @Override + public GregtechItemList set(ItemStack aStack) { + mHasNotBeenSet = false; + mStack = GT_Utility.copyAmount(1, aStack); + return this; + } + + @Override + public Item getItem() { + if (mHasNotBeenSet) throw new IllegalAccessError("The Enum '" + name() + "' has not been set to an Item at this time!"); + if (GT_Utility.isStackInvalid(mStack)) return null; + return mStack.getItem(); + } + + @Override + public Block getBlock() { + if (mHasNotBeenSet) throw new IllegalAccessError("The Enum '" + name() + "' has not been set to an Item at this time!"); + return GT_Utility.getBlockFromStack(getItem()); + } + + @Override + public final boolean hasBeenSet() { + return !mHasNotBeenSet; + } + + @Override + public boolean isStackEqual(Object aStack) { + return isStackEqual(aStack, false, false); + } + + @Override + public boolean isStackEqual(Object aStack, boolean aWildcard, boolean aIgnoreNBT) { + if (GT_Utility.isStackInvalid(aStack)) return false; + return GT_Utility.areUnificationsEqual((ItemStack)aStack, aWildcard?getWildcard(1):get(1), aIgnoreNBT); + } + + @Override + public ItemStack get(long aAmount, Object... aReplacements) { + if (mHasNotBeenSet) throw new IllegalAccessError("The Enum '" + name() + "' has not been set to an Item at this time!"); + if (GT_Utility.isStackInvalid(mStack)) return GT_Utility.copyAmount(aAmount, aReplacements); + return GT_Utility.copyAmount(aAmount, GT_OreDictUnificator.get(mStack)); + } + + @Override + public ItemStack getWildcard(long aAmount, Object... aReplacements) { + if (mHasNotBeenSet) throw new IllegalAccessError("The Enum '" + name() + "' has not been set to an Item at this time!"); + if (GT_Utility.isStackInvalid(mStack)) return GT_Utility.copyAmount(aAmount, aReplacements); + return GT_Utility.copyAmountAndMetaData(aAmount, W, GT_OreDictUnificator.get(mStack)); + } + + @Override + public ItemStack getUndamaged(long aAmount, Object... aReplacements) { + if (mHasNotBeenSet) throw new IllegalAccessError("The Enum '" + name() + "' has not been set to an Item at this time!"); + if (GT_Utility.isStackInvalid(mStack)) return GT_Utility.copyAmount(aAmount, aReplacements); + return GT_Utility.copyAmountAndMetaData(aAmount, 0, GT_OreDictUnificator.get(mStack)); + } + + @Override + public ItemStack getAlmostBroken(long aAmount, Object... aReplacements) { + if (mHasNotBeenSet) throw new IllegalAccessError("The Enum '" + name() + "' has not been set to an Item at this time!"); + if (GT_Utility.isStackInvalid(mStack)) return GT_Utility.copyAmount(aAmount, aReplacements); + return GT_Utility.copyAmountAndMetaData(aAmount, mStack.getMaxDamage()-1, GT_OreDictUnificator.get(mStack)); + } + + @Override + public ItemStack getWithName(long aAmount, String aDisplayName, Object... aReplacements) { + ItemStack rStack = get(1, aReplacements); + if (GT_Utility.isStackInvalid(rStack)) return null; + rStack.setStackDisplayName(aDisplayName); + return GT_Utility.copyAmount(aAmount, rStack); + } + + @Override + public ItemStack getWithCharge(long aAmount, int aEnergy, Object... aReplacements) { + ItemStack rStack = get(1, aReplacements); + if (GT_Utility.isStackInvalid(rStack)) return null; + GT_ModHandler.chargeElectricItem(rStack, aEnergy, Integer.MAX_VALUE, true, false); + return GT_Utility.copyAmount(aAmount, rStack); + } + + @Override + public ItemStack getWithDamage(long aAmount, long aMetaValue, Object... aReplacements) { + if (mHasNotBeenSet) throw new IllegalAccessError("The Enum '" + name() + "' has not been set to an Item at this time!"); + if (GT_Utility.isStackInvalid(mStack)) return GT_Utility.copyAmount(aAmount, aReplacements); + return GT_Utility.copyAmountAndMetaData(aAmount, aMetaValue, GT_OreDictUnificator.get(mStack)); + } + + @Override + public GregtechItemList registerOre(Object... aOreNames) { + if (mHasNotBeenSet) throw new IllegalAccessError("The Enum '" + name() + "' has not been set to an Item at this time!"); + for (Object tOreName : aOreNames) GT_OreDictUnificator.registerOre(tOreName, get(1)); + return this; + } + + @Override + public GregtechItemList registerWildcardAsOre(Object... aOreNames) { + if (mHasNotBeenSet) throw new IllegalAccessError("The Enum '" + name() + "' has not been set to an Item at this time!"); + for (Object tOreName : aOreNames) GT_OreDictUnificator.registerOre(tOreName, getWildcard(1)); + return this; + } +} \ No newline at end of file diff --git a/src/Java/miscutil/gregtech/api/enums/GregtechTextures.java b/src/Java/miscutil/gregtech/api/enums/GregtechTextures.java new file mode 100644 index 0000000000..40c3cb7f4e --- /dev/null +++ b/src/Java/miscutil/gregtech/api/enums/GregtechTextures.java @@ -0,0 +1,127 @@ +package miscutil.gregtech.api.enums; + +import static gregtech.api.enums.GT_Values.RES_PATH_BLOCK; +import gregtech.api.GregTech_API; +import gregtech.api.interfaces.IIconContainer; +import gregtech.api.interfaces.ITexture; +import net.minecraft.client.renderer.texture.TextureMap; +import net.minecraft.util.IIcon; +import net.minecraft.util.ResourceLocation; + +public class GregtechTextures { + public enum BlockIcons implements IIconContainer, Runnable { + + + LARGECENTRIFUGE_TI1, LARGECENTRIFUGE_TI2, LARGECENTRIFUGE_TI3, LARGECENTRIFUGE_TI4, LARGECENTRIFUGE_TI5, + LARGECENTRIFUGE_TI6, LARGECENTRIFUGE_TI7, LARGECENTRIFUGE_TI8, LARGECENTRIFUGE_TI9, + LARGECENTRIFUGE_TI_ACTIVE1, LARGECENTRIFUGE_TI_ACTIVE2, LARGECENTRIFUGE_TI_ACTIVE3, LARGECENTRIFUGE_TI_ACTIVE4, + LARGECENTRIFUGE_TI_ACTIVE5, LARGECENTRIFUGE_TI_ACTIVE6, LARGECENTRIFUGE_TI_ACTIVE7, LARGECENTRIFUGE_TI_ACTIVE8, LARGECENTRIFUGE_TI_ACTIVE9, + + LARGECENTRIFUGE_TU1, LARGECENTRIFUGE_TU2, LARGECENTRIFUGE_TU3, LARGECENTRIFUGE_TU4, LARGECENTRIFUGE_TU5, + LARGECENTRIFUGE_TU6, LARGECENTRIFUGE_TU7, LARGECENTRIFUGE_TU8, LARGECENTRIFUGE_TU9, + LARGECENTRIFUGE_TU_ACTIVE1, LARGECENTRIFUGE_TU_ACTIVE2, LARGECENTRIFUGE_TU_ACTIVE3, LARGECENTRIFUGE_TU_ACTIVE4, LARGECENTRIFUGE_TU_ACTIVE5, + LARGECENTRIFUGE_TU_ACTIVE6, LARGECENTRIFUGE_TU_ACTIVE7, LARGECENTRIFUGE_TU_ACTIVE8, LARGECENTRIFUGE_TU_ACTIVE9; + + public static final IIconContainer[] + + CENTRIFUGE1 = new IIconContainer[]{ + LARGECENTRIFUGE_TI1, + LARGECENTRIFUGE_TI2, + LARGECENTRIFUGE_TI3, + LARGECENTRIFUGE_TI4, + LARGECENTRIFUGE_TI5, + LARGECENTRIFUGE_TI6, + LARGECENTRIFUGE_TI7, + LARGECENTRIFUGE_TI8, + LARGECENTRIFUGE_TI9 + }, + CENTRIFUGE_ACTIVE1 = new IIconContainer[]{ + LARGECENTRIFUGE_TI_ACTIVE1, + LARGECENTRIFUGE_TI_ACTIVE2, + LARGECENTRIFUGE_TI_ACTIVE3, + LARGECENTRIFUGE_TI_ACTIVE4, + LARGECENTRIFUGE_TI_ACTIVE5, + LARGECENTRIFUGE_TI_ACTIVE6, + LARGECENTRIFUGE_TI_ACTIVE7, + LARGECENTRIFUGE_TI_ACTIVE8, + LARGECENTRIFUGE_TI_ACTIVE9 + }, + CENTRIFUGE2 = new IIconContainer[]{ + LARGECENTRIFUGE_TU1, + LARGECENTRIFUGE_TU2, + LARGECENTRIFUGE_TU3, + LARGECENTRIFUGE_TU4, + LARGECENTRIFUGE_TU5, + LARGECENTRIFUGE_TU6, + LARGECENTRIFUGE_TU7, + LARGECENTRIFUGE_TU8, + LARGECENTRIFUGE_TU9 + }, + CENTRIFUGE_ACTIVE2 = new IIconContainer[]{ + LARGECENTRIFUGE_TU_ACTIVE1, + LARGECENTRIFUGE_TU_ACTIVE2, + LARGECENTRIFUGE_TU_ACTIVE3, + LARGECENTRIFUGE_TU_ACTIVE4, + LARGECENTRIFUGE_TU_ACTIVE5, + LARGECENTRIFUGE_TU_ACTIVE6, + LARGECENTRIFUGE_TU_ACTIVE7, + LARGECENTRIFUGE_TU_ACTIVE8, + LARGECENTRIFUGE_TU_ACTIVE9 + }; + + public static ITexture[] + GT_CASING_BLOCKS = new ITexture[64]; + + protected IIcon mIcon; + + @Override + public IIcon getIcon() { + return mIcon; + } + + @Override + public IIcon getOverlayIcon() { + return null; + } + + @Override + public void run() { + mIcon = GregTech_API.sBlockIcons.registerIcon(RES_PATH_BLOCK + "iconsets/" + this); + } + + @Override + public ResourceLocation getTextureFile() { + return TextureMap.locationBlocksTexture; + } + + public static class CustomIcon implements IIconContainer, Runnable { + protected IIcon mIcon; + protected String mIconName; + + public CustomIcon(String aIconName) { + mIconName = aIconName; + GregTech_API.sGTBlockIconload.add(this); + } + + @Override + public IIcon getIcon() { + return mIcon; + } + + @Override + public IIcon getOverlayIcon() { + return null; + } + + @Override + public void run() { + mIcon = GregTech_API.sBlockIcons.registerIcon(RES_PATH_BLOCK + mIconName); + } + + @Override + public ResourceLocation getTextureFile() { + return TextureMap.locationBlocksTexture; + } + } +}} + diff --git a/src/Java/miscutil/gregtech/api/gui/CONTAINER_IronBlastFurnace.java b/src/Java/miscutil/gregtech/api/gui/CONTAINER_IronBlastFurnace.java new file mode 100644 index 0000000000..3015e43f2a --- /dev/null +++ b/src/Java/miscutil/gregtech/api/gui/CONTAINER_IronBlastFurnace.java @@ -0,0 +1,31 @@ +package miscutil.gregtech.api.gui; + +import gregtech.api.gui.GT_ContainerMetaTile_Machine; +import gregtech.api.gui.GT_Slot_Output; +import gregtech.api.interfaces.tileentity.IGregTechTileEntity; +import net.minecraft.entity.player.InventoryPlayer; +import net.minecraft.inventory.Slot; + +public class CONTAINER_IronBlastFurnace extends GT_ContainerMetaTile_Machine { + public CONTAINER_IronBlastFurnace(InventoryPlayer aInventoryPlayer, IGregTechTileEntity aTileEntity) { + super(aInventoryPlayer, aTileEntity); + } + + @Override + public void addSlots(InventoryPlayer aInventoryPlayer) { + addSlotToContainer(new Slot(this.mTileEntity, 0, 34, 16)); + addSlotToContainer(new Slot(this.mTileEntity, 1, 34, 34)); + addSlotToContainer(new GT_Slot_Output(this.mTileEntity, 2, 86, 25)); + addSlotToContainer(new GT_Slot_Output(this.mTileEntity, 3, 104, 25)); + } + + @Override + public int getSlotCount() { + return 4; + } + + @Override + public int getShiftClickSlotCount() { + return 2; + } +} diff --git a/src/Java/miscutil/gregtech/api/gui/CONTAINER_SafeBlock.java b/src/Java/miscutil/gregtech/api/gui/CONTAINER_SafeBlock.java new file mode 100644 index 0000000000..a805585a49 --- /dev/null +++ b/src/Java/miscutil/gregtech/api/gui/CONTAINER_SafeBlock.java @@ -0,0 +1,120 @@ +package miscutil.gregtech.api.gui; + +import gregtech.api.gui.GT_ContainerMetaTile_Machine; +import gregtech.api.gui.GT_Slot_Holo; +import gregtech.api.interfaces.tileentity.IGregTechTileEntity; +import miscutil.core.util.PlayerCache; +import miscutil.gregtech.api.metatileentity.implementations.GregtechMetaSafeBlock; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.entity.player.InventoryPlayer; +import net.minecraft.inventory.Slot; +import net.minecraft.item.ItemStack; + +public class CONTAINER_SafeBlock +extends GT_ContainerMetaTile_Machine { + public CONTAINER_SafeBlock(InventoryPlayer aInventoryPlayer, IGregTechTileEntity aTileEntity) { + super(aInventoryPlayer, aTileEntity); + } + + //public String UUID = ((BaseMetaTileEntity)mTileEntity).getMetaTileEntity().getBaseMetaTileEntity().getOwnerName(); + public String ownerUUID = ((GregtechMetaSafeBlock)this.mTileEntity.getMetaTileEntity()).ownerUUID; + public String tempPlayer = PlayerCache.lookupPlayerByUUID(ownerUUID); + public boolean blockStatus = ((GregtechMetaSafeBlock)this.mTileEntity.getMetaTileEntity()).bUnbreakable; + + @Override + public void addSlots(InventoryPlayer aInventoryPlayer) { + for (int y = 0; y < 3; y++) { + for (int x = 0; x < 9; x++) { + addSlotToContainer(new Slot(this.mTileEntity, x + y * 9, 8 + x * 18, 5 + y * 18)); + } + } + addSlotToContainer(new GT_Slot_Holo(this.mTileEntity, 27, 8, 63, false, true, 1)); + addSlotToContainer(new GT_Slot_Holo(this.mTileEntity, 27, 26, 63, false, true, 1)); + addSlotToContainer(new GT_Slot_Holo(this.mTileEntity, 27, 44, 63, false, true, 1)); + } + + @Override + public ItemStack slotClick(int aSlotIndex, int aMouseclick, int aShifthold, EntityPlayer aPlayer) { + int runs = 0; + if (aSlotIndex < 27) { + return super.slotClick(aSlotIndex, aMouseclick, aShifthold, aPlayer); + } + Slot tSlot = (Slot) this.inventorySlots.get(aSlotIndex); + if (tSlot != null) { + if (this.mTileEntity.getMetaTileEntity() == null) { + return null; + } + if (aSlotIndex == 27) { + + + /*((GregtechMetaSafeBlock) this.mTileEntity.getMetaTileEntity()).bOutput = (!((GregtechMetaSafeBlock) this.mTileEntity.getMetaTileEntity()).bOutput); + if (((GregtechMetaSafeBlock) this.mTileEntity.getMetaTileEntity()).bOutput) { + if (aPlayer != null && aPlayer instanceof EntityPlayerMP && (((GregtechMetaSafeBlock)this.mTileEntity.getMetaTileEntity()).bOutput != false)) { + + Utils.LOG_INFO(String.valueOf(Sys.is64Bit())); + Utils.messagePlayer(aPlayer, "Salmon"); + } + + GT_Utility.sendChatToPlayer(aPlayer, "Emit Energy to Outputside"); + } else { + GT_Utility.sendChatToPlayer(aPlayer, "Don't emit Energy"); + } + return null;*/ + + + } + if (aSlotIndex == 28) {} + /* ((GregtechMetaSafeBlock) this.mTileEntity.getMetaTileEntity()).bRedstoneIfFull = (!((GregtechMetaSafeBlock) this.mTileEntity.getMetaTileEntity()).bRedstoneIfFull); + if (((GregtechMetaSafeBlock) this.mTileEntity.getMetaTileEntity()).bRedstoneIfFull) { + GT_Utility.sendChatToPlayer(aPlayer, "Emit Redstone if no Slot is free"); + } else { + GT_Utility.sendChatToPlayer(aPlayer, "Don't emit Redstone"); + } + return null; + }*/ + if (aSlotIndex == 29) /*{ + if (((GregtechMetaSafeBlock) this.mTileEntity.getMetaTileEntity()).bUnbreakable) { + if (((GregtechMetaSafeBlock) this.mTileEntity.getMetaTileEntity()).bUnbreakable) { + makeIndestructible(aPlayer); + } + else { + + } + } else { + makeIndestructible(aPlayer); + } + return null; + }*/ + + { + ((GregtechMetaSafeBlock) this.mTileEntity.getMetaTileEntity()).bUnbreakable = (!((GregtechMetaSafeBlock) this.mTileEntity.getMetaTileEntity()).bUnbreakable); + blockStatus = ((GregtechMetaSafeBlock)this.mTileEntity.getMetaTileEntity()).bUnbreakable; + ownerUUID = ((GregtechMetaSafeBlock)this.mTileEntity.getMetaTileEntity()).ownerUUID; + //Utils.messagePlayer(aPlayer, "Is the safe locked? "+String.valueOf(((GregtechMetaSafeBlock) this.mTileEntity.getMetaTileEntity()).bUnbreakable).toUpperCase()); + /*if (aPlayer != null && aPlayer instanceof EntityPlayerMP && (((GregtechMetaSafeBlock)this.mTileEntity.getMetaTileEntity()).bUnbreakable != false)) { + UnbreakableBlockManager Xasda = new UnbreakableBlockManager(); + Xasda.setmTileEntity((BaseMetaTileEntity) mTileEntity, aPlayer); + } + else { + UnbreakableBlockManager Xasda = new UnbreakableBlockManager(); + Xasda.setmTileEntity((BaseMetaTileEntity) mTileEntity, aPlayer); + }*/ + return null; + } + + + } + return super.slotClick(aSlotIndex, aMouseclick, aShifthold, aPlayer); + } + + @Override + public int getSlotCount() { + return 27; + } + + @Override + public int getShiftClickSlotCount() { + return 27; + } + +} diff --git a/src/Java/miscutil/gregtech/api/gui/CONTAINER_SteamCondenser.java b/src/Java/miscutil/gregtech/api/gui/CONTAINER_SteamCondenser.java new file mode 100644 index 0000000000..9a283b8de3 --- /dev/null +++ b/src/Java/miscutil/gregtech/api/gui/CONTAINER_SteamCondenser.java @@ -0,0 +1,97 @@ +package miscutil.gregtech.api.gui; + +import gregtech.api.gui.GT_ContainerMetaTile_Machine; +import gregtech.api.interfaces.tileentity.IGregTechTileEntity; + +import java.util.Iterator; + +import miscutil.gregtech.api.metatileentity.implementations.base.GregtechMetaBoilerBase; +import net.minecraft.entity.player.InventoryPlayer; +import net.minecraft.inventory.ICrafting; +import net.minecraft.inventory.Slot; +import cpw.mods.fml.relauncher.Side; +import cpw.mods.fml.relauncher.SideOnly; + +public class CONTAINER_SteamCondenser extends GT_ContainerMetaTile_Machine +{ + public CONTAINER_SteamCondenser(InventoryPlayer aInventoryPlayer, IGregTechTileEntity aTileEntity, int aSteamCapacity) + { + super(aInventoryPlayer, aTileEntity); + this.mSteamCapacity = aSteamCapacity; + } + + @Override +public void addSlots(InventoryPlayer aInventoryPlayer) + { + addSlotToContainer(new Slot(this.mTileEntity, 2, 116, 62)); + addSlotToContainer(new Slot(this.mTileEntity, 0, 44, 26)); + addSlotToContainer(new Slot(this.mTileEntity, 1, 44, 62)); + addSlotToContainer(new Slot(this.mTileEntity, 3, 116, 26)); + } + + @Override +public int getSlotCount() + { + return 4; + } + + @Override +public int getShiftClickSlotCount() + { + return 1; + } + + public int mWaterAmount = 0; + public int mSteamAmount = 0; + public int mProcessingEnergy = 0; + public int mTemperature = 2; + private final int mSteamCapacity; + public long mTickingTime = ((GregtechMetaBoilerBase)this.mTileEntity.getMetaTileEntity()).RI; + + @Override +public void detectAndSendChanges() + { + super.detectAndSendChanges(); + if ((this.mTileEntity.isClientSide()) || (this.mTileEntity.getMetaTileEntity() == null)) { + return; + } + this.mTemperature = ((GregtechMetaBoilerBase)this.mTileEntity.getMetaTileEntity()).mTemperature; + this.mProcessingEnergy = ((GregtechMetaBoilerBase)this.mTileEntity.getMetaTileEntity()).mProcessingEnergy; + this.mSteamAmount = (((GregtechMetaBoilerBase)this.mTileEntity.getMetaTileEntity()).mSteam == null ? 0 : ((GregtechMetaBoilerBase)this.mTileEntity.getMetaTileEntity()).mSteam.amount); + this.mWaterAmount = (((GregtechMetaBoilerBase)this.mTileEntity.getMetaTileEntity()).mFluid == null ? 0 : ((GregtechMetaBoilerBase)this.mTileEntity.getMetaTileEntity()).mFluid.amount); + this.mTickingTime = ((GregtechMetaBoilerBase)this.mTileEntity.getMetaTileEntity()).RI; + + this.mTemperature = Math.min(54, Math.max(0, this.mTemperature * 54 / (((GregtechMetaBoilerBase)this.mTileEntity.getMetaTileEntity()).maxProgresstime() - 10))); + this.mSteamAmount = Math.min(54, Math.max(0, this.mSteamAmount * 54 / (this.mSteamCapacity - 100))); + this.mWaterAmount = Math.min(54, Math.max(0, this.mWaterAmount * 54 / 15900)); + this.mProcessingEnergy = Math.min(14, Math.max(this.mProcessingEnergy > 0 ? 1 : 0, this.mProcessingEnergy * 14 / 1000)); + + Iterator var2 = this.crafters.iterator(); + while (var2.hasNext()) + { + ICrafting var1 = (ICrafting)var2.next(); + var1.sendProgressBarUpdate(this, 100, this.mTemperature); + var1.sendProgressBarUpdate(this, 101, this.mProcessingEnergy); + var1.sendProgressBarUpdate(this, 102, this.mSteamAmount); + var1.sendProgressBarUpdate(this, 103, this.mWaterAmount); + } + } + + @Override +@SideOnly(Side.CLIENT) + public void updateProgressBar(int par1, int par2) + { + super.updateProgressBar(par1, par2); + switch (par1) + { + case 100: + this.mTemperature = par2; break; + case 101: + this.mProcessingEnergy = par2; break; + case 102: + this.mSteamAmount = par2; break; + case 103: + this.mWaterAmount = par2; + } + } +} \ No newline at end of file diff --git a/src/Java/miscutil/gregtech/api/gui/GUI_IronBlastFurnace.java b/src/Java/miscutil/gregtech/api/gui/GUI_IronBlastFurnace.java new file mode 100644 index 0000000000..6f8c42cbaa --- /dev/null +++ b/src/Java/miscutil/gregtech/api/gui/GUI_IronBlastFurnace.java @@ -0,0 +1,30 @@ +package miscutil.gregtech.api.gui; + +import gregtech.api.gui.GT_GUIContainerMetaTile_Machine; +import gregtech.api.interfaces.tileentity.IGregTechTileEntity; +import miscutil.core.lib.CORE; +import net.minecraft.entity.player.InventoryPlayer; + +public class GUI_IronBlastFurnace + extends GT_GUIContainerMetaTile_Machine { + public GUI_IronBlastFurnace(InventoryPlayer aInventoryPlayer, IGregTechTileEntity aTileEntity) { + super(new CONTAINER_IronBlastFurnace(aInventoryPlayer, aTileEntity), CORE.MODID+":textures/gui/IronBlastFurnace.png"); + } + + @Override + protected void drawGuiContainerForegroundLayer(int par1, int par2) { + this.fontRendererObj.drawString("Iron Blast Furnace", 8, 4, 4210752); + } + + @Override + protected void drawGuiContainerBackgroundLayer(float par1, int par2, int par3) { + super.drawGuiContainerBackgroundLayer(par1, par2, par3); + int x = (this.width - this.xSize) / 2; + int y = (this.height - this.ySize) / 2; + drawTexturedModalRect(x, y, 0, 0, this.xSize, this.ySize); + if ((this.mContainer != null) && + (this.mContainer.mProgressTime > 0)) { + drawTexturedModalRect(x + 58, y + 28, 176, 0, Math.max(0, Math.min(20, (this.mContainer.mProgressTime > 0 ? 1 : 0) + this.mContainer.mProgressTime * 20 / (this.mContainer.mMaxProgressTime < 1 ? 1 : this.mContainer.mMaxProgressTime))), 11); + } + } +} diff --git a/src/Java/miscutil/gregtech/api/gui/GUI_SafeBlock.java b/src/Java/miscutil/gregtech/api/gui/GUI_SafeBlock.java new file mode 100644 index 0000000000..165e4cb6ea --- /dev/null +++ b/src/Java/miscutil/gregtech/api/gui/GUI_SafeBlock.java @@ -0,0 +1,49 @@ +package miscutil.gregtech.api.gui; + +import gregtech.api.gui.GT_GUIContainerMetaTile_Machine; +import gregtech.api.interfaces.tileentity.IGregTechTileEntity; +import miscutil.core.lib.CORE; +import net.minecraft.entity.player.InventoryPlayer; + +public class GUI_SafeBlock + extends GT_GUIContainerMetaTile_Machine { + public GUI_SafeBlock(InventoryPlayer aInventoryPlayer, IGregTechTileEntity aTileEntity) { + super(new CONTAINER_SafeBlock(aInventoryPlayer, aTileEntity), CORE.MODID + ":" + "textures/gui/" + "SafeBlock.png"); + } + + //String UUID = ((CONTAINER_SafeBlock)this.mContainer).ownerUUID.toString(); + boolean blockStatus = ((CONTAINER_SafeBlock)this.mContainer).blockStatus; + //String tempPlayer; + + private void updateVars(){ + //UUID = ((CONTAINER_SafeBlock)this.mContainer).ownerUUID; + blockStatus = ((CONTAINER_SafeBlock)this.mContainer).blockStatus; + // tempPlayer = PlayerCache.lookupPlayerByUUID(UUID); + } + + @Override + protected void drawGuiContainerForegroundLayer(int par1, int par2) + { + updateVars(); + //this.fontRendererObj.drawString("Owner: "+ tempPlayer, 64, 72, 4210752); + //this.fontRendererObj.drawString(": "+ UUID.toLowerCase(), 44, 82, 4210752); + this.fontRendererObj.drawString("Safe Status", 76, 61, 4210752); + if (blockStatus){ + this.fontRendererObj.drawString("Locked", 88, 73, 4210752); + } + else { + this.fontRendererObj.drawString("Unlocked", 82, 73, 4210752); + } + } + + @Override + protected void drawGuiContainerBackgroundLayer(float par1, int par2, int par3) { + super.drawGuiContainerBackgroundLayer(par1, par2, par3); + int x = (this.width - this.xSize) / 2; + int y = (this.height - this.ySize) / 2; + drawTexturedModalRect(x, y, 0, 0, this.xSize, this.ySize); + /*String UUID = ((CONTAINER_SafeBlock)this.mContainer).UUID; + this.fontRendererObj.drawString("Owner UUID: "+ UUID, 8, 12, 4210752);*/ + + } +} diff --git a/src/Java/miscutil/gregtech/api/gui/GUI_SteamCondenser.java b/src/Java/miscutil/gregtech/api/gui/GUI_SteamCondenser.java new file mode 100644 index 0000000000..1c125e86fd --- /dev/null +++ b/src/Java/miscutil/gregtech/api/gui/GUI_SteamCondenser.java @@ -0,0 +1,55 @@ +package miscutil.gregtech.api.gui; + +import gregtech.api.gui.GT_GUIContainerMetaTile_Machine; +import gregtech.api.interfaces.tileentity.IGregTechTileEntity; +import miscutil.core.lib.CORE; +import net.minecraft.entity.player.InventoryPlayer; + +public class GUI_SteamCondenser extends GT_GUIContainerMetaTile_Machine +{ + long tickTime = 0; + + public GUI_SteamCondenser(InventoryPlayer aInventoryPlayer, IGregTechTileEntity aTileEntity, String aTextureName, int aSteamCapacity) + { + super(new CONTAINER_SteamCondenser(aInventoryPlayer, aTileEntity, aSteamCapacity), CORE.MODID + ":" + "textures/gui/" + aTextureName); + } + + @Override +protected void drawGuiContainerForegroundLayer(int par1, int par2) + { + this.fontRendererObj.drawString("Condenser", 8, 4, 4210752); + if (!CORE.DEBUG){ + tickTime = ((CONTAINER_SteamCondenser)this.mContainer).mTickingTime; + this.fontRendererObj.drawString("Tick Time: "+tickTime, 8, 12, 4210752); + } + } + + @Override +protected void drawGuiContainerBackgroundLayer(float par1, int par2, int par3) + { + super.drawGuiContainerBackgroundLayer(par1, par2, par3); + int x = (this.width - this.xSize) / 2; + int y = (this.height - this.ySize) / 2; + drawTexturedModalRect(x, y, 0, 0, this.xSize, this.ySize); + if (this.mContainer != null) + { + + int tScale = ((CONTAINER_SteamCondenser)this.mContainer).mSteamAmount; + if (tScale > 0) { + drawTexturedModalRect(x + 70, y + 25 + 54 - tScale, 194, 54 - tScale, 10, tScale); + } + tScale = ((CONTAINER_SteamCondenser)this.mContainer).mWaterAmount; + if (tScale > 0) { + drawTexturedModalRect(x + 83, y + 25 + 54 - tScale, 204, 54 - tScale, 10, tScale); + } + tScale = ((CONTAINER_SteamCondenser)this.mContainer).mTemperature; + if (tScale > 0) { + drawTexturedModalRect(x + 96, y + 25 + 54 - tScale, 214, 54 - tScale, 10, tScale); + } + tScale = ((CONTAINER_SteamCondenser)this.mContainer).mProcessingEnergy; + if (tScale > 0) { + drawTexturedModalRect(x + 115, y + 44 + 2/* - tScale*/, 177, 14 - tScale, 15, 1+tScale); + } + } + } +} \ No newline at end of file diff --git a/src/Java/miscutil/gregtech/api/init/InitGregtech.java b/src/Java/miscutil/gregtech/api/init/InitGregtech.java new file mode 100644 index 0000000000..1507405f0c --- /dev/null +++ b/src/Java/miscutil/gregtech/api/init/InitGregtech.java @@ -0,0 +1,31 @@ +package miscutil.gregtech.api.init; + +import static miscutil.core.lib.LoadedMods.Gregtech; +import miscutil.core.util.Utils; +import miscutil.gregtech.api.init.machines.GregtechConduits; +import miscutil.gregtech.api.init.machines.GregtechEnergyBuffer; +import miscutil.gregtech.api.init.machines.GregtechSafeBlock; +import miscutil.gregtech.api.init.machines.GregtechSteamCondenser; + +public class InitGregtech { + + public static void run() { + if (Gregtech) { + Utils.LOG_INFO("MiscUtils: Gregtech5u Content | Registering Meta-TileEntities."); + } + + + + /*** + * Load up Blocks classes + ***/ + + // Machines + // GregtechCobbleGenerator.run(); TODO - Weird Textures + GregtechEnergyBuffer.run(); + GregtechConduits.run(); + GregtechSteamCondenser.run(); + GregtechSafeBlock.run(); + + } +} diff --git a/src/Java/miscutil/gregtech/api/init/machines/GregtechCobbleGenerator.java b/src/Java/miscutil/gregtech/api/init/machines/GregtechCobbleGenerator.java new file mode 100644 index 0000000000..3b6d0834a1 --- /dev/null +++ b/src/Java/miscutil/gregtech/api/init/machines/GregtechCobbleGenerator.java @@ -0,0 +1,51 @@ +package miscutil.gregtech.api.init.machines; + +import gregtech.api.enums.ItemList; +import gregtech.api.enums.Materials; +import gregtech.api.enums.OreDictNames; +import gregtech.api.enums.OrePrefixes; +import gregtech.api.util.GT_ModHandler; +import miscutil.gregtech.api.enums.GregtechItemList; +import miscutil.gregtech.api.metatileentity.implementations.base.GregtechSteelBoiler; +import cpw.mods.fml.common.FMLLog; + +public class GregtechCobbleGenerator +{ + public static void run() + { + if (miscutil.core.lib.LoadedMods.Gregtech){ + FMLLog.info("MiscUtils: Registering Cobblestone Powered Engines."); + run1(); + } + + } + + private static void run1() + { + //Cobble Generators + // ItemList.Machine_Steel_Boiler.set(new GT_MetaTileEntity_Boiler_Steel(101, "boiler.steel", "High Pressure Coal Boiler").getStackForm(1L)); + // GT_ModHandler.addCraftingRecipe(ItemList.Machine_Steel_Boiler.get(1L, new Object[0]), GT_ModHandler.RecipeBits.NOT_REMOVABLE | GT_ModHandler.RecipeBits.REVERSIBLE | GT_ModHandler.RecipeBits.BUFFERED, new Object[] { "PPP", "P P", "BFB", Character.valueOf('F'), OreDictNames.craftingFurnace, Character.valueOf('P'), OrePrefixes.plate.get(Materials.Steel), Character.valueOf('B'), new ItemStack(Blocks.brick_block, 1) }); + + GregtechItemList.Cobble_Generator_ULV.set(new GregtechSteelBoiler(760, "CobGen.01.tier.00", "Ultra Low Voltage Cobblestone Generator", 0, "You're shit.").getStackForm(1L)); + GregtechItemList.Cobble_Generator_LV.set(new GregtechSteelBoiler(761, "CobGen.01.tier.01", "Low Voltage Cobblestone Generator", 1, "Still Pretty garbage, bro.").getStackForm(1L)); + GregtechItemList.Cobble_Generator_MV.set(new GregtechSteelBoiler(762, "CobGen.01.tier.02", "Medium Voltage Cobblestone Generator", 2, "Testy Test.").getStackForm(1L)); + GregtechItemList.Cobble_Generator_HV.set(new GregtechSteelBoiler(763, "CobGen.01.tier.03", "High Voltage Cobblestone Generator", 3, "").getStackForm(1L)); + GregtechItemList.Cobble_Generator_EV.set(new GregtechSteelBoiler(764, "CobGen.01.tier.04", "Extreme Voltage Cobblestone Generator", 4, "").getStackForm(1L)); + GregtechItemList.Cobble_Generator_IV.set(new GregtechSteelBoiler(765, "CobGen.01.tier.05", "Insane Voltage Cobblestone Generator", 5, "").getStackForm(1L)); + GregtechItemList.Cobble_Generator_LuV.set(new GregtechSteelBoiler(766, "CobGen.01.tier.06", "Ludicrous Voltage Cobblestone Generator", 6, "").getStackForm(1L)); + GregtechItemList.Cobble_Generator_ZPM.set(new GregtechSteelBoiler(767, "CobGen.01.tier.07", "ZPM Voltage Cobblestone Generator", 7, "").getStackForm(1L)); + GregtechItemList.Cobble_Generator_UV.set(new GregtechSteelBoiler(768, "CobGen.01.tier.08", "Ultimate Voltage Cobblestone Generator", 8, "").getStackForm(1L)); + GregtechItemList.Cobble_Generator_MAX.set(new GregtechSteelBoiler(769, "CobGen.01.tier.09", "MAX Voltage Cobblestone Generator", 9, "").getStackForm(1L)); + + GT_ModHandler.addCraftingRecipe(GregtechItemList.Cobble_Generator_ULV.get(1L, new Object[0]), GT_ModHandler.RecipeBits.DISMANTLEABLE | GT_ModHandler.RecipeBits.NOT_REMOVABLE | GT_ModHandler.RecipeBits.REVERSIBLE | GT_ModHandler.RecipeBits.BUFFERED, new Object[] { "WTW", "WMW", Character.valueOf('M'), ItemList.Hull_ULV, Character.valueOf('W'), OrePrefixes.wireGt04.get(Materials.Lead), Character.valueOf('T'), OreDictNames.craftingChest }); + GT_ModHandler.addCraftingRecipe(GregtechItemList.Cobble_Generator_LV.get(1L, new Object[0]), GT_ModHandler.RecipeBits.DISMANTLEABLE | GT_ModHandler.RecipeBits.NOT_REMOVABLE | GT_ModHandler.RecipeBits.REVERSIBLE | GT_ModHandler.RecipeBits.BUFFERED, new Object[] { "WTW", "WMW", Character.valueOf('M'), ItemList.Hull_LV, Character.valueOf('W'), OrePrefixes.wireGt04.get(Materials.Tin), Character.valueOf('T'), OreDictNames.craftingChest }); + GT_ModHandler.addCraftingRecipe(GregtechItemList.Cobble_Generator_MV.get(1L, new Object[0]), GT_ModHandler.RecipeBits.DISMANTLEABLE | GT_ModHandler.RecipeBits.NOT_REMOVABLE | GT_ModHandler.RecipeBits.REVERSIBLE | GT_ModHandler.RecipeBits.BUFFERED, new Object[] { "WTW", "WMW", Character.valueOf('M'), ItemList.Hull_MV, Character.valueOf('W'), OrePrefixes.wireGt04.get(Materials.AnyCopper), Character.valueOf('T'), OreDictNames.craftingChest }); + GT_ModHandler.addCraftingRecipe(GregtechItemList.Cobble_Generator_HV.get(1L, new Object[0]), GT_ModHandler.RecipeBits.DISMANTLEABLE | GT_ModHandler.RecipeBits.NOT_REMOVABLE | GT_ModHandler.RecipeBits.REVERSIBLE | GT_ModHandler.RecipeBits.BUFFERED, new Object[] { "WTW", "WMW", Character.valueOf('M'), ItemList.Hull_HV, Character.valueOf('W'), OrePrefixes.wireGt04.get(Materials.Gold), Character.valueOf('T'), OreDictNames.craftingChest }); + GT_ModHandler.addCraftingRecipe(GregtechItemList.Cobble_Generator_EV.get(1L, new Object[0]), GT_ModHandler.RecipeBits.DISMANTLEABLE | GT_ModHandler.RecipeBits.NOT_REMOVABLE | GT_ModHandler.RecipeBits.REVERSIBLE | GT_ModHandler.RecipeBits.BUFFERED, new Object[] { "WTW", "WMW", Character.valueOf('M'), ItemList.Hull_EV, Character.valueOf('W'), OrePrefixes.wireGt04.get(Materials.Aluminium), Character.valueOf('T'), OreDictNames.craftingChest }); + GT_ModHandler.addCraftingRecipe(GregtechItemList.Cobble_Generator_IV.get(1L, new Object[0]), GT_ModHandler.RecipeBits.DISMANTLEABLE | GT_ModHandler.RecipeBits.NOT_REMOVABLE | GT_ModHandler.RecipeBits.REVERSIBLE | GT_ModHandler.RecipeBits.BUFFERED, new Object[] { "WTW", "WMW", Character.valueOf('M'), ItemList.Hull_IV, Character.valueOf('W'), OrePrefixes.wireGt04.get(Materials.Tungsten), Character.valueOf('T'), OreDictNames.craftingChest }); + GT_ModHandler.addCraftingRecipe(GregtechItemList.Cobble_Generator_LuV.get(1L, new Object[0]), GT_ModHandler.RecipeBits.DISMANTLEABLE | GT_ModHandler.RecipeBits.NOT_REMOVABLE | GT_ModHandler.RecipeBits.REVERSIBLE | GT_ModHandler.RecipeBits.BUFFERED, new Object[] { "WTW", "WMW", Character.valueOf('M'), ItemList.Hull_LuV, Character.valueOf('W'), OrePrefixes.wireGt04.get(Materials.Osmium), Character.valueOf('T'), OreDictNames.craftingChest }); + GT_ModHandler.addCraftingRecipe(GregtechItemList.Cobble_Generator_ZPM.get(1L, new Object[0]), GT_ModHandler.RecipeBits.DISMANTLEABLE | GT_ModHandler.RecipeBits.NOT_REMOVABLE | GT_ModHandler.RecipeBits.REVERSIBLE | GT_ModHandler.RecipeBits.BUFFERED, new Object[] { "WTW", "WMW", Character.valueOf('M'), ItemList.Hull_ZPM, Character.valueOf('W'), OrePrefixes.wireGt04.get(Materials.Osmium), Character.valueOf('T'), OreDictNames.craftingChest }); + GT_ModHandler.addCraftingRecipe(GregtechItemList.Cobble_Generator_UV.get(1L, new Object[0]), GT_ModHandler.RecipeBits.DISMANTLEABLE | GT_ModHandler.RecipeBits.NOT_REMOVABLE | GT_ModHandler.RecipeBits.REVERSIBLE | GT_ModHandler.RecipeBits.BUFFERED, new Object[] { "WTW", "WMW", Character.valueOf('M'), ItemList.Hull_UV, Character.valueOf('W'), OrePrefixes.wireGt04.get(Materials.Osmium), Character.valueOf('T'), OreDictNames.craftingChest }); + GT_ModHandler.addCraftingRecipe(GregtechItemList.Cobble_Generator_MAX.get(1L, new Object[0]), GT_ModHandler.RecipeBits.DISMANTLEABLE | GT_ModHandler.RecipeBits.NOT_REMOVABLE | GT_ModHandler.RecipeBits.REVERSIBLE | GT_ModHandler.RecipeBits.BUFFERED, new Object[] { "WTW", "WMW", Character.valueOf('M'), ItemList.Hull_MAX, Character.valueOf('W'), OrePrefixes.wireGt04.get(Materials.Superconductor), Character.valueOf('T'), OreDictNames.craftingChest }); + } +} diff --git a/src/Java/miscutil/gregtech/api/init/machines/GregtechConduits.java b/src/Java/miscutil/gregtech/api/init/machines/GregtechConduits.java new file mode 100644 index 0000000000..318ff5f882 --- /dev/null +++ b/src/Java/miscutil/gregtech/api/init/machines/GregtechConduits.java @@ -0,0 +1,103 @@ +package miscutil.gregtech.api.init.machines; + +import static miscutil.core.lib.LoadedMods.Gregtech; +import gregtech.api.enums.GT_Values; +import gregtech.api.enums.Materials; +import gregtech.api.enums.OrePrefixes; +import gregtech.api.util.GT_OreDictUnificator; +import miscutil.core.lib.LoadedMods; +import miscutil.core.util.Utils; +import miscutil.gregtech.api.metatileentity.implementations.GregtechMetaPipeEntity_Cable; + +public class GregtechConduits { + /** + * + * The Voltage Tiers. Use this Array instead of the old named Voltage Variables + * public static final long[] V = new long[] {0=8, 1=32, 2=128, 3=512, 4=2048, 5=8192, 6=32768, 7=131072, 8=524288, 9=Integer.MAX_VALUE, Integer.MAX_VALUE, Integer.MAX_VALUE, Integer.MAX_VALUE, Integer.MAX_VALUE, Integer.MAX_VALUE, Integer.MAX_VALUE}; + * + */ + + + public static void run() + { + if (Gregtech){ + Utils.LOG_INFO("MiscUtils: Gregtech5u Content | Registering Custom Cables/Wire."); + run1(); + } + + } + + private static void run1(){ + if (LoadedMods.Big_Reactors){ + wireFactory("Blutonium", 8196, 30600, 8, 32, 2); + wireFactory("Cyanite", 512, 30615, 2, 16, 4); + wireFactory("Yellorium", 2048, 30630, 4, 16, 2); + } + if (LoadedMods.EnderIO){ + wireFactory("RedstoneAlloy", 32, 30645, 1, 4, 1); + } + + } + + private static void wireFactory(String Material, int Voltage, int ID, long insulatedLoss, long uninsulatedLoss, long Amps){ + Materials T = Materials.valueOf(Material); + int V = 0; + if (Voltage == 8){ + V = 0; + } + else if (Voltage == 32){ + V = 1; + } + else if (Voltage == 128){ + V = 2; + } + else if (Voltage == 512){ + V = 3; + } + else if (Voltage == 2048){ + V = 4; + } + else if (Voltage == 8196){ + V = 5; + } + else if (Voltage == 32768){ + V = 6; + } + else if (Voltage == 131072){ + V = 7; + } + else if (Voltage == 524288){ + V = 8; + } + else if (Voltage == Integer.MAX_VALUE){ + V = 9; + } + else { + Utils.LOG_ERROR("Failed to set voltage on "+Material+". Invalid voltage of "+Voltage+"V set."); + Utils.LOG_ERROR(Material+" has defaulted to 8v."); + V = 0; + } + //makeWires(T, ID, 2L, 4L, 2L, GT_Values.V[V], true, false); + makeWires(T, ID, insulatedLoss, uninsulatedLoss, Amps, GT_Values.V[V], true, false); + //makeWires(T, ID, bEC ? 2L : 2L, bEC ? 4L : 4L, 2L, gregtech.api.enums.GT_Values.V[V], true, false); + } + + private static void makeWires(Materials aMaterial, int aStartID, long aLossInsulated, long aLoss, long aAmperage, long aVoltage, boolean aInsulatable, boolean aAutoInsulated) + { + Utils.LOG_WARNING("MiscUtils: Gregtech5u Content | Registered "+aMaterial.name() +" as a new material for Wire & Cable."); + GT_OreDictUnificator.registerOre(OrePrefixes.wireGt01, aMaterial, new GregtechMetaPipeEntity_Cable(aStartID + 0, "wire." + aMaterial.name().toLowerCase() + ".01", "1x " + aMaterial.mDefaultLocalName + " Wire", 0.125F, aMaterial, aLoss, 1L * aAmperage, aVoltage, false, !aAutoInsulated).getStackForm(1L)); + GT_OreDictUnificator.registerOre(OrePrefixes.wireGt02, aMaterial, new GregtechMetaPipeEntity_Cable(aStartID + 1, "wire." + aMaterial.name().toLowerCase() + ".02", "2x " + aMaterial.mDefaultLocalName + " Wire", 0.25F, aMaterial, aLoss, 2L * aAmperage, aVoltage, false, !aAutoInsulated).getStackForm(1L)); + GT_OreDictUnificator.registerOre(OrePrefixes.wireGt04, aMaterial, new GregtechMetaPipeEntity_Cable(aStartID + 2, "wire." + aMaterial.name().toLowerCase() + ".04", "4x " + aMaterial.mDefaultLocalName + " Wire", 0.375F, aMaterial, aLoss, 4L * aAmperage, aVoltage, false, !aAutoInsulated).getStackForm(1L)); + GT_OreDictUnificator.registerOre(OrePrefixes.wireGt08, aMaterial, new GregtechMetaPipeEntity_Cable(aStartID + 3, "wire." + aMaterial.name().toLowerCase() + ".08", "8x " + aMaterial.mDefaultLocalName + " Wire", 0.5F, aMaterial, aLoss, 8L * aAmperage, aVoltage, false, !aAutoInsulated).getStackForm(1L)); + GT_OreDictUnificator.registerOre(OrePrefixes.wireGt12, aMaterial, new GregtechMetaPipeEntity_Cable(aStartID + 4, "wire." + aMaterial.name().toLowerCase() + ".12", "12x " + aMaterial.mDefaultLocalName + " Wire", 0.75F, aMaterial, aLoss, 12L * aAmperage, aVoltage, false, !aAutoInsulated).getStackForm(1L)); + GT_OreDictUnificator.registerOre(OrePrefixes.wireGt16, aMaterial, new GregtechMetaPipeEntity_Cable(aStartID + 5, "wire." + aMaterial.name().toLowerCase() + ".16", "16x " + aMaterial.mDefaultLocalName + " Wire", 1.0F, aMaterial, aLoss, 16L * aAmperage, aVoltage, false, !aAutoInsulated).getStackForm(1L)); + if (aInsulatable) + { + GT_OreDictUnificator.registerOre(OrePrefixes.cableGt01, aMaterial, new GregtechMetaPipeEntity_Cable(aStartID + 6, "cable." + aMaterial.name().toLowerCase() + ".01", "1x " + aMaterial.mDefaultLocalName + " Cable", 0.25F, aMaterial, aLossInsulated, 1L * aAmperage, aVoltage, true, false).getStackForm(1L)); + GT_OreDictUnificator.registerOre(OrePrefixes.cableGt02, aMaterial, new GregtechMetaPipeEntity_Cable(aStartID + 7, "cable." + aMaterial.name().toLowerCase() + ".02", "2x " + aMaterial.mDefaultLocalName + " Cable", 0.375F, aMaterial, aLossInsulated, 2L * aAmperage, aVoltage, true, false).getStackForm(1L)); + GT_OreDictUnificator.registerOre(OrePrefixes.cableGt04, aMaterial, new GregtechMetaPipeEntity_Cable(aStartID + 8, "cable." + aMaterial.name().toLowerCase() + ".04", "4x " + aMaterial.mDefaultLocalName + " Cable", 0.5F, aMaterial, aLossInsulated, 4L * aAmperage, aVoltage, true, false).getStackForm(1L)); + GT_OreDictUnificator.registerOre(OrePrefixes.cableGt08, aMaterial, new GregtechMetaPipeEntity_Cable(aStartID + 9, "cable." + aMaterial.name().toLowerCase() + ".08", "8x " + aMaterial.mDefaultLocalName + " Cable", 0.75F, aMaterial, aLossInsulated, 8L * aAmperage, aVoltage, true, false).getStackForm(1L)); + GT_OreDictUnificator.registerOre(OrePrefixes.cableGt12, aMaterial, new GregtechMetaPipeEntity_Cable(aStartID + 10, "cable." + aMaterial.name().toLowerCase() + ".12", "12x " + aMaterial.mDefaultLocalName + " Cable", 1.0F, aMaterial, aLossInsulated, 12L * aAmperage, aVoltage, true, false).getStackForm(1L)); + } + } +} diff --git a/src/Java/miscutil/gregtech/api/init/machines/GregtechEnergyBuffer.java b/src/Java/miscutil/gregtech/api/init/machines/GregtechEnergyBuffer.java new file mode 100644 index 0000000000..c54e9f9d76 --- /dev/null +++ b/src/Java/miscutil/gregtech/api/init/machines/GregtechEnergyBuffer.java @@ -0,0 +1,83 @@ +package miscutil.gregtech.api.init.machines; + +import gregtech.api.enums.ItemList; +import gregtech.api.enums.Materials; +import gregtech.api.enums.OrePrefixes; +import gregtech.api.util.GT_ModHandler; +import miscutil.core.util.Utils; +import miscutil.gregtech.api.enums.ExtraOreDictNames; +import miscutil.gregtech.api.enums.GregtechItemList; +import miscutil.gregtech.api.metatileentity.implementations.GregtechMetaCreativeEnergyBuffer; +import miscutil.gregtech.api.metatileentity.implementations.GregtechMetaEnergyBuffer; + +public class GregtechEnergyBuffer +{ + + //Misc Items + //public static Item itemBufferCore; + + public static void run() + { + if (miscutil.core.lib.LoadedMods.Gregtech){ + Utils.LOG_INFO("MiscUtils: Gregtech5u Content | Registering Energy Buffer Blocks."); + run1(); + } + + } + + @SuppressWarnings("deprecation") + private static void run1() + { + + //itemBufferCore = new Item().setUnlocalizedName("itemBufferCore").setCreativeTab(AddToCreativeTab.tabMisc).setTextureName(CORE.MODID + ":itemBufferCore"); + + //Registry + //GameRegistry.registerItem(itemBufferCore, "itemBufferCore"); + //LanguageRegistry.addName(itemBufferCore, "Buffer Core"); + //OreDictionary.registerOre("itemBufferCore", itemBufferCore); + + + //Energy Buffers + GregtechItemList.Energy_Buffer_1by1_ULV.set(new GregtechMetaEnergyBuffer(770, "energybuffer.01.tier.00", "Ultra Low Voltage Energy Buffer", 0, "", 1).getStackForm(1L)); + GregtechItemList.Energy_Buffer_1by1_LV.set(new GregtechMetaEnergyBuffer(771, "energybuffer.01.tier.01", "Low Voltage Energy Buffer", 1, "", 1).getStackForm(1L)); + GregtechItemList.Energy_Buffer_1by1_MV.set(new GregtechMetaEnergyBuffer(772, "energybuffer.01.tier.02", "Medium Voltage Energy Buffer", 2, "", 1).getStackForm(1L)); + GregtechItemList.Energy_Buffer_1by1_HV.set(new GregtechMetaEnergyBuffer(773, "energybuffer.01.tier.03", "High Voltage Energy Buffer", 3, "", 1).getStackForm(1L)); + GregtechItemList.Energy_Buffer_1by1_EV.set(new GregtechMetaEnergyBuffer(774, "energybuffer.01.tier.04", "Extreme Voltage Energy Buffer", 4, "", 1).getStackForm(1L)); + GregtechItemList.Energy_Buffer_1by1_IV.set(new GregtechMetaEnergyBuffer(775, "energybuffer.01.tier.05", "Insane Voltage Energy Buffer", 5, "", 1).getStackForm(1L)); + GregtechItemList.Energy_Buffer_1by1_LuV.set(new GregtechMetaEnergyBuffer(776, "energybuffer.01.tier.06", "Ludicrous Voltage Energy Buffer", 6, "", 1).getStackForm(1L)); + GregtechItemList.Energy_Buffer_1by1_ZPM.set(new GregtechMetaEnergyBuffer(777, "energybuffer.01.tier.07", "ZPM Voltage Energy Buffer", 7, "", 1).getStackForm(1L)); + GregtechItemList.Energy_Buffer_1by1_UV.set(new GregtechMetaEnergyBuffer(778,