From bf2225eb1b02d0095c9136a4ad37cc267f1ec107 Mon Sep 17 00:00:00 2001 From: Draknyte1 Date: Sun, 14 Aug 2016 19:59:40 +1000 Subject: + Added the basework for Super Conductivity related machines & cabling. > Lossless power transfer is always nice, eh? % Refactored a few tooltips on machines. % Refactored some classes around. - Removed some obscure legacy code, which added a Cobblestone fueled boiler (Why?) --- .../miscutil/core/block/base/BlockBaseModular.java | 6 +- src/Java/miscutil/core/handler/COMPAT_HANDLER.java | 2 + .../events/PickaxeBlockBreakEventHandler.java | 2 +- .../gregtech/GregtechCobbleGenerator.java | 51 - .../registration/gregtech/GregtechConduits.java | 55 + .../gregtech/GregtechSuperConductionPoint.java | 27 + .../core/item/general/ItemCloakingDevice.java | 4 +- .../core/item/general/ItemHealingDevice.java | 27 +- .../core/item/tool/staballoy/StaballoyAxe.java | 42 +- .../xmod/gregtech/api/enums/GregtechItemList.java | 4 +- .../gregtech/api/enums/GregtechOrePrefixes.java | 1 + .../gregtech/api/gui/CONTAINER_SteamCondenser.java | 2 +- .../implementations/GregtechMetaCondensor.java | 2 +- .../GregtechMetaPipeEntity_SuperConductor.java | 239 +++ .../implementations/GregtechMetaSafeBlock.java | 2 +- .../GregtechMetaSuperConductorNodeBase.java | 297 ++++ .../base/GregtechMetaBoilerBase.java | 328 ---- .../base/GregtechMetaPipeEntityBase_Cable.java | 291 +++ .../base/GregtechMetaSafeBlockBase.java | 343 ---- .../base/GregtechMetaSolarGenerator.java | 211 --- .../base/GregtechMetaTileEntity.java | 4 +- .../base/GregtechRocketFuelGeneratorBase.java | 263 --- .../implementations/base/GregtechSteelBoiler.java | 290 --- .../base/generators/GregtechMetaBoilerBase.java | 328 ++++ .../generators/GregtechMetaSolarGenerator.java | 211 +++ .../GregtechRocketFuelGeneratorBase.java | 263 +++ .../GregtechBaseMetaTileEntityLossless.java | 1849 ++++++++++++++++++++ .../GregtechMetaPipeEntity_BaseSuperConductor.java | 640 +++++++ .../lossless/GregtechMetaTileEntityLossless.java | 66 + .../GregtechMetaTileEntityLosslessBasicTank.java | 251 +++ ...chMetaTileEntityLosslessTieredMachineBlock.java | 67 + .../base/lossless/MetaTileEntityLossless.java | 865 +++++++++ .../base/machines/GregtechMetaSafeBlockBase.java | 343 ++++ .../creative/GregtechMetaCreativeEnergyBuffer.java | 3 +- .../GregtechMetaTileEntityRocketFuelGenerator.java | 2 +- .../GregtechMetaTileEntitySolarGenerator.java | 2 +- .../GregtechMetaTileEntitySuperCondensor.java | 104 ++ 37 files changed, 5954 insertions(+), 1533 deletions(-) delete mode 100644 src/Java/miscutil/core/handler/registration/gregtech/GregtechCobbleGenerator.java create mode 100644 src/Java/miscutil/core/handler/registration/gregtech/GregtechSuperConductionPoint.java create mode 100644 src/Java/miscutil/core/xmod/gregtech/api/metatileentity/implementations/GregtechMetaPipeEntity_SuperConductor.java create mode 100644 src/Java/miscutil/core/xmod/gregtech/api/metatileentity/implementations/GregtechMetaSuperConductorNodeBase.java delete mode 100644 src/Java/miscutil/core/xmod/gregtech/api/metatileentity/implementations/base/GregtechMetaBoilerBase.java create mode 100644 src/Java/miscutil/core/xmod/gregtech/api/metatileentity/implementations/base/GregtechMetaPipeEntityBase_Cable.java delete mode 100644 src/Java/miscutil/core/xmod/gregtech/api/metatileentity/implementations/base/GregtechMetaSafeBlockBase.java delete mode 100644 src/Java/miscutil/core/xmod/gregtech/api/metatileentity/implementations/base/GregtechMetaSolarGenerator.java delete mode 100644 src/Java/miscutil/core/xmod/gregtech/api/metatileentity/implementations/base/GregtechRocketFuelGeneratorBase.java delete mode 100644 src/Java/miscutil/core/xmod/gregtech/api/metatileentity/implementations/base/GregtechSteelBoiler.java create mode 100644 src/Java/miscutil/core/xmod/gregtech/api/metatileentity/implementations/base/generators/GregtechMetaBoilerBase.java create mode 100644 src/Java/miscutil/core/xmod/gregtech/api/metatileentity/implementations/base/generators/GregtechMetaSolarGenerator.java create mode 100644 src/Java/miscutil/core/xmod/gregtech/api/metatileentity/implementations/base/generators/GregtechRocketFuelGeneratorBase.java create mode 100644 src/Java/miscutil/core/xmod/gregtech/api/metatileentity/implementations/base/lossless/GregtechBaseMetaTileEntityLossless.java create mode 100644 src/Java/miscutil/core/xmod/gregtech/api/metatileentity/implementations/base/lossless/GregtechMetaPipeEntity_BaseSuperConductor.java create mode 100644 src/Java/miscutil/core/xmod/gregtech/api/metatileentity/implementations/base/lossless/GregtechMetaTileEntityLossless.java create mode 100644 src/Java/miscutil/core/xmod/gregtech/api/metatileentity/implementations/base/lossless/GregtechMetaTileEntityLosslessBasicTank.java create mode 100644 src/Java/miscutil/core/xmod/gregtech/api/metatileentity/implementations/base/lossless/GregtechMetaTileEntityLosslessTieredMachineBlock.java create mode 100644 src/Java/miscutil/core/xmod/gregtech/api/metatileentity/implementations/base/lossless/MetaTileEntityLossless.java create mode 100644 src/Java/miscutil/core/xmod/gregtech/api/metatileentity/implementations/base/machines/GregtechMetaSafeBlockBase.java create mode 100644 src/Java/miscutil/core/xmod/gregtech/common/tileentities/generators/GregtechMetaTileEntitySuperCondensor.java (limited to 'src/Java') diff --git a/src/Java/miscutil/core/block/base/BlockBaseModular.java b/src/Java/miscutil/core/block/base/BlockBaseModular.java index 106eb50954..5e0bc163c2 100644 --- a/src/Java/miscutil/core/block/base/BlockBaseModular.java +++ b/src/Java/miscutil/core/block/base/BlockBaseModular.java @@ -28,13 +28,13 @@ public class BlockBaseModular extends BasicBlock{ this.setBlockName(getLocalizedName()); if (thisBlock == BlockTypes.STANDARD){ - LanguageRegistry.addName(this, "Block of "+unlocalizedName); + LanguageRegistry.addName(this, "Block of "+blockMaterial); } else if (thisBlock == BlockTypes.FRAME){ - LanguageRegistry.addName(this, unlocalizedName+ " Frame Box"); + LanguageRegistry.addName(this, blockMaterial+ " Frame Box"); } else { - LanguageRegistry.addName(this, unlocalizedName); + LanguageRegistry.addName(this, blockMaterial); } //setOreDict(unlocalizedName, blockType); diff --git a/src/Java/miscutil/core/handler/COMPAT_HANDLER.java b/src/Java/miscutil/core/handler/COMPAT_HANDLER.java index 174b9f005e..8c408bdd4f 100644 --- a/src/Java/miscutil/core/handler/COMPAT_HANDLER.java +++ b/src/Java/miscutil/core/handler/COMPAT_HANDLER.java @@ -33,6 +33,7 @@ import miscutil.core.handler.registration.gregtech.GregtechRocketFuelGenerator; import miscutil.core.handler.registration.gregtech.GregtechSafeBlock; import miscutil.core.handler.registration.gregtech.GregtechSolarGenerators; import miscutil.core.handler.registration.gregtech.GregtechSteamCondenser; +import miscutil.core.handler.registration.gregtech.GregtechSuperConductionPoint; import miscutil.core.item.ModItems; import miscutil.core.lib.CORE; import miscutil.core.lib.LoadedMods; @@ -84,6 +85,7 @@ public class COMPAT_HANDLER { GregtechConduits.run(); GregtechSteamCondenser.run(); GregtechSafeBlock.run(); + GregtechSuperConductionPoint.run(); GregtechIronBlastFurnace.run(); GregtechIndustrialCentrifuge.run(); GregtechIndustrialCokeOven.run(); diff --git a/src/Java/miscutil/core/handler/events/PickaxeBlockBreakEventHandler.java b/src/Java/miscutil/core/handler/events/PickaxeBlockBreakEventHandler.java index 9f5cdb943e..c8865ee02e 100644 --- a/src/Java/miscutil/core/handler/events/PickaxeBlockBreakEventHandler.java +++ b/src/Java/miscutil/core/handler/events/PickaxeBlockBreakEventHandler.java @@ -5,7 +5,7 @@ import gregtech.api.metatileentity.BaseMetaPipeEntity; import gregtech.api.metatileentity.BaseMetaTileEntity; import gregtech.api.metatileentity.BaseTileEntity; import miscutil.core.util.Utils; -import miscutil.core.xmod.gregtech.api.metatileentity.implementations.base.GregtechMetaSafeBlockBase; +import miscutil.core.xmod.gregtech.api.metatileentity.implementations.base.machines.GregtechMetaSafeBlockBase; import net.minecraft.block.Block; import net.minecraft.entity.player.EntityPlayer; import net.minecraft.tileentity.TileEntity; diff --git a/src/Java/miscutil/core/handler/registration/gregtech/GregtechCobbleGenerator.java b/src/Java/miscutil/core/handler/registration/gregtech/GregtechCobbleGenerator.java deleted file mode 100644 index eae786f4aa..0000000000 --- a/src/Java/miscutil/core/handler/registration/gregtech/GregtechCobbleGenerator.java +++ /dev/null @@ -1,51 +0,0 @@ -package miscutil.core.handler.registration.gregtech; - -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.core.xmod.gregtech.api.enums.GregtechItemList; -import miscutil.core.xmod.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("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/core/handler/registration/gregtech/GregtechConduits.java b/src/Java/miscutil/core/handler/registration/gregtech/GregtechConduits.java index 9c10df196c..7a70e7873b 100644 --- a/src/Java/miscutil/core/handler/registration/gregtech/GregtechConduits.java +++ b/src/Java/miscutil/core/handler/registration/gregtech/GregtechConduits.java @@ -7,7 +7,9 @@ import gregtech.api.enums.OrePrefixes; import gregtech.api.util.GT_OreDictUnificator; import miscutil.core.lib.LoadedMods; import miscutil.core.util.Utils; +import miscutil.core.xmod.gregtech.api.enums.GregtechOrePrefixes.GT_Materials; import miscutil.core.xmod.gregtech.api.metatileentity.implementations.GregtechMetaPipeEntity_Cable; +import miscutil.core.xmod.gregtech.api.metatileentity.implementations.GregtechMetaPipeEntity_SuperConductor; public class GregtechConduits { /** @@ -37,6 +39,9 @@ public class GregtechConduits { wireFactory("RedstoneAlloy", 32, 30645, 1, 4, 1); } + superConductorFactory("Superconductor", 524288, 30660, 0, 0, 8); + superConductorFactory("VoidMetal", 512, 30661, 0, 0, 8); + } private static void wireFactory(String Material, int Voltage, int ID, long insulatedLoss, long uninsulatedLoss, long Amps){ @@ -100,4 +105,54 @@ public class GregtechConduits { 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)); } } + + private static void superConductorFactory(String Material, int Voltage, int ID, long insulatedLoss, long uninsulatedLoss, long Amps){ + GT_Materials T = GT_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); + makeSuperConductors(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 makeSuperConductors(GT_Materials aMaterial, int aStartID, long aLossInsulated, long aLoss, long aAmperage, long aVoltage, boolean aInsulatable, boolean aAutoInsulated) + { + Utils.LOG_WARNING("Gregtech5u Content | Registered "+aMaterial.name() +" as a new Super Conductor."); + GT_OreDictUnificator.registerOre(OrePrefixes.wireGt16, aMaterial, new GregtechMetaPipeEntity_SuperConductor(aStartID + 5, "wire." + aMaterial.name().toLowerCase() + ".16", "16x " + aMaterial.mDefaultLocalName + " Wire", 1.0F, aMaterial, aLoss, 16L * aAmperage, aVoltage, false, !aAutoInsulated).getStackForm(1L)); + + } } diff --git a/src/Java/miscutil/core/handler/registration/gregtech/GregtechSuperConductionPoint.java b/src/Java/miscutil/core/handler/registration/gregtech/GregtechSuperConductionPoint.java new file mode 100644 index 0000000000..d2434dd46f --- /dev/null +++ b/src/Java/miscutil/core/handler/registration/gregtech/GregtechSuperConductionPoint.java @@ -0,0 +1,27 @@ +package miscutil.core.handler.registration.gregtech; + +import miscutil.core.util.Utils; +import miscutil.core.xmod.gregtech.api.enums.GregtechItemList; +import miscutil.core.xmod.gregtech.common.tileentities.generators.GregtechMetaTileEntitySuperCondensor; + +public class GregtechSuperConductionPoint +{ + + + + public static void run() + { + if (miscutil.core.lib.LoadedMods.Gregtech){ + Utils.LOG_INFO("Gregtech5u Content | Registering Super Conductor Input Node."); + run1(); + } + + } + + private static void run1() + { + //Steam Condensors + GregtechItemList.SuperConductorInputNode.set(new GregtechMetaTileEntitySuperCondensor(801, "superconductor.01.input.single", "Super Condensor", 3).getStackForm(1L)); + + } +} diff --git a/src/Java/miscutil/core/item/general/ItemCloakingDevice.java b/src/Java/miscutil/core/item/general/ItemCloakingDevice.java index 64e45f34b9..b54bb08a87 100644 --- a/src/Java/miscutil/core/item/general/ItemCloakingDevice.java +++ b/src/Java/miscutil/core/item/general/ItemCloakingDevice.java @@ -27,7 +27,7 @@ public class ItemCloakingDevice extends Item implements IElectricItem, IElectric private final String unlocalizedName = "personalCloakingDevice"; private final ItemStack thisStack; - private final static int maxValueEU = 100000000; + private final static int maxValueEU = 8196*20*5*60; protected double chargeEU = 0; public ItemCloakingDevice(){ @@ -131,7 +131,7 @@ public class ItemCloakingDevice extends Item implements IElectricItem, IElectric list.add(""); list.add(EnumChatFormatting.GOLD+"IC2/EU Information"+EnumChatFormatting.GRAY); list.add(EnumChatFormatting.GRAY+"Tier: ["+EnumChatFormatting.YELLOW+getTier(thisStack)+EnumChatFormatting.GRAY+"] Transfer Limit: ["+EnumChatFormatting.YELLOW+getTransferLimit(thisStack)+EnumChatFormatting.GRAY +"Eu/t]"); - list.add(EnumChatFormatting.GRAY+"Current Power: ["+EnumChatFormatting.YELLOW+(long) getCharge(stack)+EnumChatFormatting.GRAY+"Eu]"); + list.add(EnumChatFormatting.GRAY+"Current Power: ["+EnumChatFormatting.YELLOW+(long) getCharge(stack)+EnumChatFormatting.GRAY+"Eu] ["+EnumChatFormatting.YELLOW+MathUtils.findPercentage(getCharge(stack), getMaxCharge(stack))+EnumChatFormatting.GRAY +"%]"); list.add(EnumChatFormatting.GRAY+"Time Remaining: ["+EnumChatFormatting.YELLOW+secondsLeft(stack)+ EnumChatFormatting.GRAY +" seconds]"); super.addInformation(stack, aPlayer, list, bool); } diff --git a/src/Java/miscutil/core/item/general/ItemHealingDevice.java b/src/Java/miscutil/core/item/general/ItemHealingDevice.java index 65c0dc2626..385ab06fdd 100644 --- a/src/Java/miscutil/core/item/general/ItemHealingDevice.java +++ b/src/Java/miscutil/core/item/general/ItemHealingDevice.java @@ -8,6 +8,7 @@ import java.util.List; import miscutil.core.creative.AddToCreativeTab; import miscutil.core.lib.CORE; +import miscutil.core.util.Utils; import miscutil.core.util.item.UtilsItems; import miscutil.core.util.math.MathUtils; import net.minecraft.entity.Entity; @@ -25,7 +26,7 @@ public class ItemHealingDevice extends Item implements IElectricItem, IElectricI private final String unlocalizedName = "personalHealingDevice"; private final ItemStack thisStack; - private final static int maxValueEU = 100000000; + private final static int maxValueEU = 1000000000; protected double chargeEU = 0; public ItemHealingDevice(){ @@ -88,18 +89,18 @@ public class ItemHealingDevice extends Item implements IElectricItem, IElectricI @Override public int getTier(ItemStack itemStack) { - return 4; + return 5; } @Override public double getTransferLimit(ItemStack itemStack) { - return 8196; + return 32784; } @Override public String getItemStackDisplayName(ItemStack p_77653_1_) { - return (EnumChatFormatting.WHITE+"Personal Healing NanoBooster"+EnumChatFormatting.GRAY); + return (EnumChatFormatting.BLUE+"Personal Healing NanoBooster"+EnumChatFormatting.RESET); } @Override @@ -118,8 +119,8 @@ public class ItemHealingDevice extends Item implements IElectricItem, IElectricI public double secondsLeft(ItemStack stack){ double r = 0; - r = getCharge(stack)/(8196*20); - return MathUtils.decimalRounding(r); + r = getCharge(stack)/(1638400/4); + return (int) r; } @Override @@ -130,7 +131,7 @@ public class ItemHealingDevice extends Item implements IElectricItem, IElectricI list.add(""); list.add(EnumChatFormatting.GOLD+"IC2/EU Information"+EnumChatFormatting.GRAY); list.add(EnumChatFormatting.GRAY+"Tier: ["+EnumChatFormatting.YELLOW+getTier(thisStack)+EnumChatFormatting.GRAY+"] Transfer Limit: ["+EnumChatFormatting.YELLOW+getTransferLimit(thisStack)+EnumChatFormatting.GRAY +"Eu/t]"); - list.add(EnumChatFormatting.GRAY+"Current Power: ["+EnumChatFormatting.YELLOW+(long) getCharge(stack)+EnumChatFormatting.GRAY+"Eu]"); + list.add(EnumChatFormatting.GRAY+"Current Power: ["+EnumChatFormatting.YELLOW+(long) getCharge(stack)+EnumChatFormatting.GRAY+"Eu] ["+EnumChatFormatting.YELLOW+MathUtils.findPercentage(getCharge(stack), getMaxCharge(stack))+EnumChatFormatting.GRAY +"%]"); list.add(EnumChatFormatting.GRAY+"Uses Remaining: ["+EnumChatFormatting.YELLOW+secondsLeft(stack)+ EnumChatFormatting.GRAY +"]"); super.addInformation(stack, aPlayer, list, bool); } @@ -211,11 +212,15 @@ public class ItemHealingDevice extends Item implements IElectricItem, IElectricI @Override //TODO public void onWornTick(ItemStack arg0, EntityLivingBase arg1) { if (!arg1.worldObj.isRemote){ - if (getCharge(arg0) >= 1638400){ - if (arg1.getHealth() < arg1.getMaxHealth()-2){ - arg1.heal(2); + if (getCharge(arg0) >= 1638400/4){ + if (arg1.getHealth() < arg1.getMaxHealth()){ + float rx = arg1.getMaxHealth()-arg1.getHealth(); + Utils.LOG_INFO("rx:"+rx); + arg1.heal(rx*2); + discharge(arg0, (1638400/4)*rx, 6, true, true, false); + Utils.messagePlayer((EntityPlayer) arg1, "Your NanoBooster Whirs! Leaving you feeling stronger. It Healed "+rx+" hp."); + Utils.messagePlayer((EntityPlayer) arg1, "You check it's remaining uses, it has "+secondsLeft(arg0)+"."); } - discharge(arg0, 1638400, 6, true, true, false); } } } diff --git a/src/Java/miscutil/core/item/tool/staballoy/StaballoyAxe.java b/src/Java/miscutil/core/item/tool/staballoy/StaballoyAxe.java index 0e66f7aae3..667c57fddc 100644 --- a/src/Java/miscutil/core/item/tool/staballoy/StaballoyAxe.java +++ b/src/Java/miscutil/core/item/tool/staballoy/StaballoyAxe.java @@ -82,7 +82,7 @@ public class StaballoyAxe extends ItemAxe{ private int check(World par1World, int x, int y, int z, int xo, int yo,int zo) { int f=0; - int o=x+z*40+y*400; + int o=x+z*20+y*400; if (tre[o]==needcheck){ tre[o]=ignore; Block bit = par1World.getBlock(x+xo, y+yo, z+zo); @@ -107,18 +107,18 @@ public class StaballoyAxe extends ItemAxe{ boolean f; for (f=true;f==true;){ f=false; - for (int y=-10;y<110;y++) - for(int z=0;z<40;z++) - for(int x=0;x<40;x++){ + for (int y=0;y<80;y++) + for(int z=0;z<20;z++) + for(int x=0;x<20;x++){ int r=check(par1World,x,y,z,xo,yo,zo); if (r==3) return 3; if (r==2) return 2; if (r==1) f=true; } - for (int y=109;y>=-10;y--) - for(int z=39;z>=0;z--) - for(int x=39;x>=0;x--){ + for (int y=79;y>=0;y--) + for(int z=19;z>=0;z--) + for(int x=19;x>=0;x--){ int r=check(par1World,x,y,z,xo,yo,zo); if (r==2) return 3; if (r==2) return 2; @@ -130,11 +130,11 @@ public class StaballoyAxe extends ItemAxe{ private int check2(World par1World, int x, int y, int z, int xo, int yo,int zo) { int f=0; - int o=x+z*40+y*400; + int o=x+z*20+y*400; if (tre[o]==needcheck){ tre[o]=ignore; Block bit = par1World.getBlock(x+xo, y+yo, z+zo); - if (bit instanceof BlockLog || (bit.getUnlocalizedName().toLowerCase().contains("log")) || (bit.getUnlocalizedName().toLowerCase().contains("wood"))){ + if (bit instanceof BlockLog){ f=1; tre[o]=harvest; //if (bit instanceof BlockLog){ @@ -156,18 +156,18 @@ public class StaballoyAxe extends ItemAxe{ boolean f; for (f=true;f==true;){ f=false; - for (int y=-10;y<110;y++) - for(int z=0;z<40;z++) - for(int x=0;x<40;x++){ + for (int y=0;y<80;y++) + for(int z=0;z<20;z++) + for(int x=0;x<20;x++){ int r=check2(par1World,x,y,z,xo,yo,zo); if (r==3) return 3; if (r==2) return 2; if (r==1) f=true; } - for (int y=109;y>=-10;y--) - for(int z=39;z>=0;z--) - for(int x=39;x>=0;x--){ + for (int y=79;y>=0;y--) + for(int z=19;z>=0;z--) + for(int x=19;x>=0;x--){ int r=check2(par1World,x,y,z,xo,yo,zo); if (r==2) return 3; if (r==2) return 2; @@ -178,15 +178,15 @@ public class StaballoyAxe extends ItemAxe{ } public void exploadTree(World par1World,int xo,int yo,int zo, EntityPlayer plr){ - for (int y=-10;y<110;y++) - for(int z=0;z<40;z++) - for(int x=0;x<40;x++){ - int o=x+z*40+y*400; + for (int y=0;y<80;y++) + for(int z=0;z<20;z++) + for(int x=0;x<20;x++){ + int o=x+z*20+y*400; if (tre[o]==harvest){ Block bit = par1World.getBlock(x+xo, y+yo, z+zo); int met = par1World.getBlockMetadata(x+xo, y+yo, z+zo); - if ((bit instanceof BlockLog)||(bit instanceof BlockLeavesBase) || (bit.getUnlocalizedName().toLowerCase().contains("log")) || (bit.getUnlocalizedName().toLowerCase().contains("wood"))){ + if ((bit instanceof BlockLog)||(bit instanceof BlockLeavesBase) || (bit.getUnlocalizedName().toLowerCase().contains("log")) || (bit.getUnlocalizedName().toLowerCase().contains("wood"))){ bit.harvestBlock(par1World, plr, x+xo, y+yo, z+zo,met); par1World.setBlockToAir(x+xo, y+yo, z+zo); } @@ -244,7 +244,7 @@ public class StaballoyAxe extends ItemAxe{ } } - if (bit instanceof BlockLog || (bit.getUnlocalizedName().toLowerCase().contains("log")) || (bit.getUnlocalizedName().toLowerCase().contains("wood"))){ + if (bit instanceof BlockLog || (bit.getUnlocalizedName().toLowerCase().contains("log")) || (bit.getUnlocalizedName().toLowerCase().contains("wood"))){ //LoonTools.log("cutting tree @ "+x+" "+y+" "+z+" "); for (int n=0;n<32000;n++) tre[n]=unchecked; int met = wld.getBlockMetadata(x, y, z); diff --git a/src/Java/miscutil/core/xmod/gregtech/api/enums/GregtechItemList.java b/src/Java/miscutil/core/xmod/gregtech/api/enums/GregtechItemList.java index 2000a1df34..6f8935c51d 100644 --- a/src/Java/miscutil/core/xmod/gregtech/api/enums/GregtechItemList.java +++ b/src/Java/miscutil/core/xmod/gregtech/api/enums/GregtechItemList.java @@ -97,7 +97,9 @@ public enum GregtechItemList implements GregtechItemContainer { Food_Baked_Raisin_Bread, - Industrial_SinterFurnace; + Industrial_SinterFurnace, + + SuperConductorInputNode; public static final GregtechItemList[] DYE_ONLY_ITEMS = { diff --git a/src/Java/miscutil/core/xmod/gregtech/api/enums/GregtechOrePrefixes.java b/src/Java/miscutil/core/xmod/gregtech/api/enums/GregtechOrePrefixes.java index ba6ad6ce41..824f7c99cb 100644 --- a/src/Java/miscutil/core/xmod/gregtech/api/enums/GregtechOrePrefixes.java +++ b/src/Java/miscutil/core/xmod/gregtech/api/enums/GregtechOrePrefixes.java @@ -308,6 +308,7 @@ public enum GregtechOrePrefixes { Neutronic(-1, TextureSet.SET_NONE, 1.0F, 0, 0, 0, 255, 255, 255, 0, "LuV Tier", 0, 0, -1, 0, false, false, 1, 1, 1, Dyes.dyeLightGray, Arrays.asList(new TC_AspectStack(TC_Aspects.ELECTRUM, 6), new TC_AspectStack(TC_Aspects.MACHINA, 6))), Quantum(-1, TextureSet.SET_NONE, 1.0F, 0, 0, 0, 255, 255, 255, 0, "ZPM Tier", 0, 0, -1, 0, false, false, 1, 1, 1, Dyes.dyeLightGray, Arrays.asList(new TC_AspectStack(TC_Aspects.ELECTRUM, 8), new TC_AspectStack(TC_Aspects.MACHINA, 8))), + Superconductor(-1, TextureSet.SET_NONE, 1.0F, 0, 0, 0, 190, 240, 190, 0, "Superconductor", 0, 0, -1, 0, false, false, 1, 1, 1, Dyes.dyeGreen, Arrays.asList(new TC_AspectStack(TC_Aspects.ELECTRUM, 8))), Staballoy(30, TextureSet.SET_ROUGH, 10.0F, 5120, 4, 1 | 2 | 16 | 32 | 64 | 128, 248, 255, 46, 0, "Staballoy", 0, 0, 1500, 2800, true, false, 1, 3, 1, Dyes.dyeGreen, 2, Arrays.asList(new MaterialStack(Materials.Titanium, 1), new MaterialStack(Materials.Uranium, 9)), Arrays.asList(new TC_AspectStack(TC_Aspects.METALLUM, 8), new TC_AspectStack(TC_Aspects.STRONTIO, 3))), Bedrockium(31, TextureSet.SET_FINE, 8.0F, 8196, 3, 1 | 2 | 16 | 32 | 64 | 128, 39, 39, 39, 0, "Bedrockium", 0, 0, -1, 0, false, false, 1, 5, 1, Dyes.dyeLightGray, 2, Arrays.asList(new MaterialStack(Materials.Carbon, 63), new MaterialStack(Materials.Carbon, 56)), Arrays.asList(new TC_AspectStack(TC_Aspects.VACUOS, 8), new TC_AspectStack(TC_Aspects.TUTAMEN, 3))), diff --git a/src/Java/miscutil/core/xmod/gregtech/api/gui/CONTAINER_SteamCondenser.java b/src/Java/miscutil/core/xmod/gregtech/api/gui/CONTAINER_SteamCondenser.java index 0cc4fc259b..0b7d80c940 100644 --- a/src/Java/miscutil/core/xmod/gregtech/api/gui/CONTAINER_SteamCondenser.java +++ b/src/Java/miscutil/core/xmod/gregtech/api/gui/CONTAINER_SteamCondenser.java @@ -5,7 +5,7 @@ import gregtech.api.interfaces.tileentity.IGregTechTileEntity; import java.util.Iterator; -import miscutil.core.xmod.gregtech.api.metatileentity.implementations.base.GregtechMetaBoilerBase; +import miscutil.core.xmod.gregtech.api.metatileentity.implementations.base.generators.GregtechMetaBoilerBase; import net.minecraft.entity.player.InventoryPlayer; import net.minecraft.inventory.ICrafting; import net.minecraft.inventory.Slot; diff --git a/src/Java/miscutil/core/xmod/gregtech/api/metatileentity/implementations/GregtechMetaCondensor.java b/src/Java/miscutil/core/xmod/gregtech/api/metatileentity/implementations/GregtechMetaCondensor.java index d069ff2c83..4ab969c483 100644 --- a/src/Java/miscutil/core/xmod/gregtech/api/metatileentity/implementations/GregtechMetaCondensor.java +++ b/src/Java/miscutil/core/xmod/gregtech/api/metatileentity/implementations/GregtechMetaCondensor.java @@ -12,7 +12,7 @@ import miscutil.core.util.Utils; import miscutil.core.util.math.MathUtils; import miscutil.core.xmod.gregtech.api.gui.CONTAINER_SteamCondenser; import miscutil.core.xmod.gregtech.api.gui.GUI_SteamCondenser; -import miscutil.core.xmod.gregtech.api.metatileentity.implementations.base.GregtechMetaBoilerBase; +import miscutil.core.xmod.gregtech.api.metatileentity.implementations.base.generators.GregtechMetaBoilerBase; import net.minecraft.entity.player.InventoryPlayer; import net.minecraftforge.common.util.ForgeDirection; import net.minecraftforge.fluids.FluidStack; diff --git a/src/Java/miscutil/core/xmod/gregtech/api/metatileentity/implementations/GregtechMetaPipeEntity_SuperConductor.java b/src/Java/miscutil/core/xmod/gregtech/api/metatileentity/implementations/GregtechMetaPipeEntity_SuperConductor.java new file mode 100644 index 0000000000..7b6c670be4 --- /dev/null +++ b/src/Java/miscutil/core/xmod/gregtech/api/metatileentity/implementations/GregtechMetaPipeEntity_SuperConductor.java @@ -0,0 +1,239 @@ +package miscutil.core.xmod.gregtech.api.metatileentity.implementations; + +import static gregtech.api.enums.GT_Values.VN; +import gregtech.api.GregTech_API; +import gregtech.api.enums.Dyes; +import gregtech.api.enums.TextureSet; +import gregtech.api.enums.Textures; +import gregtech.api.interfaces.ITexture; +import gregtech.api.interfaces.metatileentity.IMetaTileEntity; +import gregtech.api.interfaces.metatileentity.IMetaTileEntityCable; +import gregtech.api.interfaces.tileentity.IColoredTileEntity; +import gregtech.api.interfaces.tileentity.IEnergyConnected; +import gregtech.api.interfaces.tileentity.IGregTechTileEntity; +import gregtech.api.metatileentity.BaseMetaPipeEntity; +import gregtech.api.objects.GT_RenderedTexture; +import gregtech.api.util.GT_Utility; +import ic2.api.energy.tile.IEnergySink; + +import java.util.ArrayList; +import java.util.Arrays; + +import miscutil.core.lib.CORE; +import miscutil.core.xmod.gregtech.api.enums.GregtechOrePrefixes.GT_Materials; +import miscutil.core.xmod.gregtech.api.metatileentity.implementations.base.GregtechMetaPipeEntityBase_Cable; +import net.minecraft.entity.Entity; +import net.minecraft.entity.EntityLivingBase; +import net.minecraft.tileentity.TileEntity; +import net.minecraft.util.AxisAlignedBB; +import net.minecraft.util.EnumChatFormatting; +import net.minecraft.world.World; +import net.minecraftforge.common.util.ForgeDirection; +import cofh.api.energy.IEnergyReceiver; + +public class GregtechMetaPipeEntity_SuperConductor extends GregtechMetaPipeEntityBase_Cable implements IMetaTileEntityCable { + public long mTransferredAmperage = 0, mTransferredAmperageLast20 = 0, mTransferredVoltageLast20 = 0; + + public final float mThickNess; + public final GT_Materials mMaterial; + public final long mCableLossPerMeter, mAmperage, mVoltage; + public final boolean mInsulated, mCanShock; + public long mRestRF; + + public GregtechMetaPipeEntity_SuperConductor(int aID, String aName, String aNameRegional, float aThickNess, GT_Materials aMaterial, long aCableLossPerMeter, long aAmperage, long aVoltage, boolean aInsulated, boolean aCanShock) { + super(aID, aName, aNameRegional, 0, aMaterial, 0, aAmperage, aVoltage, aInsulated, aCanShock); + mThickNess = aThickNess; + mMaterial = aMaterial; + mAmperage = aAmperage; + mVoltage = aVoltage; + mInsulated = aInsulated; + mCanShock = aCanShock; + mCableLossPerMeter = 0; + } + + public GregtechMetaPipeEntity_SuperConductor(String aName, float aThickNess, GT_Materials aMaterial, long aCableLossPerMeter, long aAmperage, long aVoltage, boolean aInsulated, boolean aCanShock) { + super(aName, 0, aMaterial, 0, aAmperage, aVoltage, aInsulated, aCanShock); + mThickNess = aThickNess; + mMaterial = aMaterial; + mAmperage = aAmperage; + mVoltage = aVoltage; + mInsulated = aInsulated; + mCanShock = aCanShock; + mCableLossPerMeter = 0; + } + + @Override + public byte getTileEntityBaseType() { + return (byte)(mInsulated?9:8); + } + + @Override + public IMetaTileEntity newMetaEntity(IGregTechTileEntity aTileEntity) { + return new GregtechMetaPipeEntity_SuperConductor(mName, mThickNess, mMaterial, mCableLossPerMeter, mAmperage, mVoltage, mInsulated, mCanShock); + } + + @Override + public ITexture[] getTexture(IGregTechTileEntity aBaseMetaTileEntity, byte aSide, byte aConnections, byte aColorIndex, boolean aConnected, boolean aRedstone) { + if (!mInsulated) return new ITexture[] {new GT_RenderedTexture(mMaterial.mIconSet.mTextures[TextureSet.INDEX_wire], mMaterial.mRGBa)}; + if (aConnected) { + float tThickNess = getThickNess(); + if (tThickNess < 0.37F) return new ITexture[] {new GT_RenderedTexture(mMaterial.mIconSet.mTextures[TextureSet.INDEX_wire], mMaterial.mRGBa), new GT_RenderedTexture(Textures.BlockIcons.INSULATION_TINY , Dyes.getModulation(aColorIndex, Dyes.CABLE_INSULATION.mRGBa))}; + if (tThickNess < 0.49F) return new ITexture[] {new GT_RenderedTexture(mMaterial.mIconSet.mTextures[TextureSet.INDEX_wire], mMaterial.mRGBa), new GT_RenderedTexture(Textures.BlockIcons.INSULATION_SMALL , Dyes.getModulation(aColorIndex, Dyes.CABLE_INSULATION.mRGBa))}; + if (tThickNess < 0.74F) return new ITexture[] {new GT_RenderedTexture(mMaterial.mIconSet.mTextures[TextureSet.INDEX_wire], mMaterial.mRGBa), new GT_RenderedTexture(Textures.BlockIcons.INSULATION_MEDIUM , Dyes.getModulation(aColorIndex, Dyes.CABLE_INSULATION.mRGBa))}; + if (tThickNess < 0.99F) return new ITexture[] {new GT_RenderedTexture(mMaterial.mIconSet.mTextures[TextureSet.INDEX_wire], mMaterial.mRGBa), new GT_RenderedTexture(Textures.BlockIcons.INSULATION_LARGE , Dyes.getModulation(aColorIndex, Dyes.CABLE_INSULATION.mRGBa))}; + return new ITexture[] {new GT_RenderedTexture(mMaterial.mIconSet.mTextures[TextureSet.INDEX_wire], mMaterial.mRGBa), new GT_RenderedTexture(Textures.BlockIcons.INSULATION_HUGE , Dyes.getModulation(aColorIndex, Dyes.CABLE_INSULATION.mRGBa))}; + } + return new ITexture[] {new GT_RenderedTexture(Textures.BlockIcons.INSULATION_FULL, Dyes.getModulation(aColorIndex, Dyes.CABLE_INSULATION.mRGBa))}; + } + + @Override + public void onEntityCollidedWithBlock(World aWorld, int aX, int aY, int aZ, Entity aEntity) { + if (mCanShock && (((BaseMetaPipeEntity)getBaseMetaTileEntity()).mConnections & -128) == 0 && aEntity instanceof EntityLivingBase) GT_Utility.applyElectricityDamage((EntityLivingBase)aEntity, mTransferredVoltageLast20, mTransferredAmperageLast20); + } + + @Override + public AxisAlignedBB getCollisionBoundingBoxFromPool(World aWorld, int aX, int aY, int aZ) { + if (!mCanShock) return super.getCollisionBoundingBoxFromPool(aWorld, aX, aY, aZ); + return AxisAlignedBB.getBoundingBox(aX+0.125D, aY+0.125D, aZ+0.125D, aX+0.875D, aY+0.875D, aZ+0.875D); + } + + @Override public boolean isSimpleMachine() {return true;} + @Override public boolean isFacingValid(byte aFacing) {return false;} + @Override public boolean isValidSlot(int aIndex) {return true;} + // @Override public final boolean renderInside(byte aSide) {return false;} + @Override public int getProgresstime() {return (int)mTransferredAmperage*64;} + @Override public int maxProgresstime() {return (int)mAmperage*64;} + + @Override + public long injectEnergyUnits(byte aSide, long aVoltage, long aAmperage) { + if (!getBaseMetaTileEntity().getCoverBehaviorAtSide(aSide).letsEnergyIn(aSide, getBaseMetaTileEntity().getCoverIDAtSide(aSide), getBaseMetaTileEntity().getCoverDataAtSide(aSide), getBaseMetaTileEntity())) return 0; + return transferElectricity(aSide, aVoltage, aAmperage, new ArrayList(Arrays.asList((TileEntity)getBaseMetaTileEntity()))); + } + + @Override + public long transferElectricity(byte aSide, long aVoltage, long aAmperage, ArrayList aAlreadyPassedTileEntityList) { + long rUsedAmperes = 0; + aVoltage -= mCableLossPerMeter; + if (aVoltage > 0) for (byte i = 0; i < 6 && aAmperage > rUsedAmperes; i++) if (i != aSide && (mConnections & (1<= 0) { + byte tColor = ((IEnergyConnected)tTileEntity).getColorization(); + if (tColor >= 0 && tColor != getBaseMetaTileEntity().getColorization()) continue; + } + if (tTileEntity instanceof IGregTechTileEntity && ((IGregTechTileEntity)tTileEntity).getMetaTileEntity() instanceof IMetaTileEntityCable && ((IGregTechTileEntity)tTileEntity).getCoverBehaviorAtSide(GT_Utility.getOppositeSide(i)).letsEnergyIn(GT_Utility.getOppositeSide(i), ((IGregTechTileEntity)tTileEntity).getCoverIDAtSide(GT_Utility.getOppositeSide(i)), ((IGregTechTileEntity)tTileEntity).getCoverDataAtSide(GT_Utility.getOppositeSide(i)), ((IGregTechTileEntity)tTileEntity))) { + if (((IGregTechTileEntity)tTileEntity).getTimer() > 50) rUsedAmperes += ((IMetaTileEntityCable)((IGregTechTileEntity)tTileEntity).getMetaTileEntity()).transferElectricity(GT_Utility.getOppositeSide(i), aVoltage, aAmperage-rUsedAmperes, aAlreadyPassedTileEntityList); + } else { + rUsedAmperes += ((IEnergyConnected)tTileEntity).injectEnergyUnits(GT_Utility.getOppositeSide(i), aVoltage, aAmperage-rUsedAmperes); + } + // } else if (tTileEntity instanceof IEnergySink) { + // ForgeDirection tDirection = ForgeDirection.getOrientation(i).getOpposite(); + // if (((IEnergySink)tTileEntity).acceptsEnergyFrom((TileEntity)getBaseMetaTileEntity(), tDirection)) { + // if (((IEnergySink)tTileEntity).demandedEnergyUnits() > 0 && ((IEnergySink)tTileEntity).injectEnergyUnits(tDirection, aVoltage) < aVoltage) rUsedAmperes++; + // } + } else if (tTileEntity instanceof IEnergySink) { + ForgeDirection tDirection = ForgeDirection.getOrientation(i).getOpposite(); + if (((IEnergySink)tTileEntity).acceptsEnergyFrom((TileEntity)getBaseMetaTileEntity(), tDirection)) { + if (((IEnergySink)tTileEntity).getDemandedEnergy() > 0 && ((IEnergySink)tTileEntity).injectEnergy(tDirection, aVoltage, aVoltage) < aVoltage) rUsedAmperes++; + } + } else if(GregTech_API.mOutputRF && tTileEntity instanceof IEnergyReceiver){ + ForgeDirection tDirection = ForgeDirection.getOrientation(i).getOpposite(); + int rfOut = (int) (aVoltage * GregTech_API.mEUtoRF / 100); + if(((IEnergyReceiver)tTileEntity).receiveEnergy(tDirection, rfOut, true)==rfOut){ + ((IEnergyReceiver)tTileEntity).receiveEnergy(tDirection, rfOut, false); rUsedAmperes++; + }else if(((IEnergyReceiver)tTileEntity).receiveEnergy(tDirection, rfOut, true)>0){ + if(mRestRF==0){ + int RFtrans = ((IEnergyReceiver)tTileEntity).receiveEnergy(tDirection, (int) rfOut, false);rUsedAmperes++; + mRestRF = rfOut - RFtrans; + }else{ + int RFtrans = ((IEnergyReceiver)tTileEntity).receiveEnergy(tDirection, (int) mRestRF, false); + mRestRF = mRestRF - RFtrans; + } + } + if(GregTech_API.mRFExplosions && ((IEnergyReceiver)tTileEntity).getMaxEnergyStored(tDirection) < rfOut * 600){ + if(rfOut > 32 * GregTech_API.mEUtoRF / 100) this.doExplosion(rfOut); + } + } + } + } + mTransferredAmperage += rUsedAmperes; + mTransferredVoltageLast20 = Math.max(mTransferredVoltageLast20, aVoltage); + mTransferredAmperageLast20 = Math.max(mTransferredAmperageLast20, mTransferredAmperage); + if (aVoltage > mVoltage || mTransferredAmperage > mAmperage) { + getBaseMetaTileEntity().setToFire(); + return aAmperage; + } + return rUsedAmperes; + } + + @Override + public void onPostTick(IGregTechTileEntity aBaseMetaTileEntity, long aTick) { + if (aBaseMetaTileEntity.isServerSide()) { + mTransferredAmperage = 0; + + if (aTick % 20 == 0) { + mTransferredVoltageLast20 = 0; + mTransferredAmperageLast20 = 0; + mConnections = 0; + for (byte i = 0, j = 0; i < 6; i++) { + j = GT_Utility.getOppositeSide(i); + if (aBaseMetaTileEntity.getCoverBehaviorAtSide(i).alwaysLookConnected(i, aBaseMetaTileEntity.getCoverIDAtSide(i), aBaseMetaTileEntity.getCoverDataAtSide(i), aBaseMetaTileEntity) || aBaseMetaTileEntity.getCoverBehaviorAtSide(i).letsEnergyIn(i, aBaseMetaTileEntity.getCoverIDAtSide(i), aBaseMetaTileEntity.getCoverDataAtSide(i), aBaseMetaTileEntity) || aBaseMetaTileEntity.getCoverBehaviorAtSide(i).letsEnergyOut(i, aBaseMetaTileEntity.getCoverIDAtSide(i), aBaseMetaTileEntity.getCoverDataAtSide(i), aBaseMetaTileEntity)) { + TileEntity tTileEntity = aBaseMetaTileEntity.getTileEntityAtSide(i); + if (tTileEntity instanceof IColoredTileEntity) { + if (aBaseMetaTileEntity.getColorization() >= 0) { + byte tColor = ((IColoredTileEntity)tTileEntity).getColorization(); + if (tColor >= 0 && tColor != aBaseMetaTileEntity.getColorization()) continue; + } + } + if (tTileEntity instanceof IEnergyConnected && (((IEnergyConnected)tTileEntity).inputEnergyFrom(j) || ((IEnergyConnected)tTileEntity).outputsEnergyTo(j))) { + mConnections |= (1< 1; + } + + @Override + public boolean isSimpleMachine() { + return false; + } + + @Override + public boolean isValidSlot(int aIndex) { + return aIndex < 2; + } + + @Override + public boolean isEnetInput() { + return true; + } + + @Override + public boolean isEnetOutput() { + return true; + } + + @Override + public boolean isOutputFacing(byte aSide) { + return true; + } + + @Override + public boolean isAccessAllowed(EntityPlayer aPlayer) { + return true; + } + + @Override + public long getMinimumStoredEU() { + return V[mTier] * 16 * mInventory.length; + } + + @Override + public long maxEUStore() { + return V[mTier] * 64; + } + + @Override + public long maxEUInput() { + return V[mTier]; + } + + @Override + public long maxEUOutput() { + return V[mTier]; + } + + @Override + public long maxAmperesIn() { + return 16; + } + + @Override + public long maxAmperesOut() { + return 16; + } + + @Override + public boolean doesFillContainers() { + return getBaseMetaTileEntity().isAllowedToWork(); + } + + @Override + public boolean doesEmptyContainers() { + return getBaseMetaTileEntity().isAllowedToWork(); + } + + @Override + public boolean canTankBeFilled() { + return getBaseMetaTileEntity().isAllowedToWork(); + } + + @Override + public boolean canTankBeEmptied() { + return getBaseMetaTileEntity().isAllowedToWork(); + } + + @Override + public boolean displaysItemStack() { + return true; + } + + @Override + public boolean displaysStackSize() { + return false; + } + + @Override + public boolean isFluidInputAllowed(FluidStack aFluid) { + return getFuelValue(aFluid) > 0; + } + + @Override + public void onPostTick(IGregTechTileEntity aBaseMetaTileEntity, long aTick) { + if (getEUVar() == maxEUStore() || mFluid == null){ + aBaseMetaTileEntity.disableWorking(); + } + else { + aBaseMetaTileEntity.enableWorking(); + } + if (aBaseMetaTileEntity.isServerSide() && aBaseMetaTileEntity.isAllowedToWork() && aTick % 10 == 0) { + if (mFluid == null) { + if (aBaseMetaTileEntity.getUniversalEnergyStored() < maxEUOutput() + getMinimumStoredEU()) { + mInventory[getStackDisplaySlot()] = null; + } else { + if (mInventory[getStackDisplaySlot()] == null) + mInventory[getStackDisplaySlot()] = new ItemStack(Blocks.fire, 1); + mInventory[getStackDisplaySlot()].setStackDisplayName("Generating: " + (aBaseMetaTileEntity.getUniversalEnergyStored() - getMinimumStoredEU()) + " EU"); + } + } else { + int tFuelValue = getFuelValue(mFluid), tConsumed = consumedFluidPerOperation(mFluid); + if (tConsumed > 0 && mFluid.amount > tConsumed) { + long tFluidAmountToUse = Math.min(mFluid.amount / tConsumed, (maxEUOutput() * 20 + getMinimumStoredEU() - aBaseMetaTileEntity.getUniversalEnergyStored())); + if (tFluidAmountToUse > 0 /*&& aBaseMetaTileEntity.increaseStoredEnergyUnits(tFluidAmountToUse * tFuelValue, true)*/) + mFluid.amount -= tFluidAmountToUse * tConsumed; + } + } + if (mInventory[getInputSlot()] != null && aBaseMetaTileEntity.getUniversalEnergyStored() < (maxEUOutput() * 20 + getMinimumStoredEU()) && GT_Utility.getFluidForFilledItem(mInventory[getInputSlot()], true) == null) { + int tFuelValue = getFuelValue(mInventory[getInputSlot()]); + if (tFuelValue >= 0) { + ItemStack tEmptyContainer = getEmptyContainer(mInventory[getInputSlot()]); + if (aBaseMetaTileEntity.addStackToSlot(getOutputSlot(), tEmptyContainer)) { + //aBaseMetaTileEntity.increaseStoredEnergyUnits(tFuelValue, true); + aBaseMetaTileEntity.decrStackSize(getInputSlot(), 1); + } + } + } + } + + if (aBaseMetaTileEntity.isServerSide()) + aBaseMetaTileEntity.setActive(aBaseMetaTileEntity.isAllowedToWork() && aBaseMetaTileEntity.getUniversalEnergyStored() >= maxEUOutput() + getMinimumStoredEU()); + } + + public abstract GT_Recipe_Map getRecipes(); + + public abstract int getEfficiency(); + + public int consumedFluidPerOperation(FluidStack aLiquid) { + return 1; + } + + public int getFuelValue(FluidStack aLiquid) { + if (aLiquid == null || getRecipes() == null) return 0; + FluidStack tLiquid; + Collection tRecipeList = getRecipes().mRecipeList; + if (tRecipeList != null) for (GT_Recipe tFuel : tRecipeList) + if ((tLiquid = GT_Utility.getFluidForFilledItem(tFuel.getRepresentativeInput(0), true)) != null) + if (aLiquid.isFluidEqual(tLiquid)) + return 0; + //return (int) (((long) tFuel.mSpecialValue * getEfficiency() * consumedFluidPerOperation(tLiquid)) / 100); + return 0; + } + + public int getFuelValue(ItemStack aStack) { + if (GT_Utility.isStackInvalid(aStack) || getRecipes() == null) return 0; + GT_Recipe tFuel = getRecipes().findRecipe(getBaseMetaTileEntity(), false, Long.MAX_VALUE, null, aStack); + if (tFuel != null) + return 0; + //return (int) ((tFuel.mSpecialValue * 1000L * getEfficiency()) / 100); + return 0; + } + + public ItemStack getEmptyContainer(ItemStack aStack) { + if (GT_Utility.isStackInvalid(aStack) || getRecipes() == null) return null; + GT_Recipe tFuel = getRecipes().findRecipe(getBaseMetaTileEntity(), false, Long.MAX_VALUE, null, aStack); + if (tFuel != null) return GT_Utility.copy(tFuel.getOutput(0)); + return GT_Utility.getContainerItem(aStack, true); + } + + @Override + public boolean allowPutStack(IGregTechTileEntity aBaseMetaTileEntity, int aIndex, byte aSide, ItemStack aStack) { + return super.allowPutStack(aBaseMetaTileEntity, aIndex, aSide, aStack) && (getFuelValue(aStack) > 0 || getFuelValue(GT_Utility.getFluidForFilledItem(aStack, true)) > 0); + } + + @Override + public int getCapacity() { + return 16000; + } + + @Override + public int getTankPressure() { + return -100; + } + + +} diff --git a/src/Java/miscutil/core/xmod/gregtech/api/metatileentity/implementations/base/GregtechMetaBoilerBase.java b/src/Java/miscutil/core/xmod/gregtech/api/metatileentity/implementations/base/GregtechMetaBoilerBase.java deleted file mode 100644 index 40ab96469b..0000000000 --- a/src/Java/miscutil/core/xmod/gregtech/api/metatileentity/implementations/base/GregtechMetaBoilerBase.java +++ /dev/null @@ -1,328 +0,0 @@ -package miscutil.core.xmod.gregtech.api.metatileentity.implementations.base; - -import gregtech.api.GregTech_API; -import gregtech.api.enums.Materials; -import gregtech.api.enums.OrePrefixes; -import gregtech.api.interfaces.ITexture; -import gregtech.api.interfaces.tileentity.IGregTechTileEntity; -import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_BasicTank; -import gregtech.api.objects.GT_ItemStack; -import gregtech.api.util.GT_ModHandler; -import gregtech.api.util.GT_OreDictUnificator; -import gregtech.api.util.GT_Utility; -import miscutil.core.util.math.MathUtils; -import net.minecraft.entity.player.EntityPlayer; -import net.minecraft.init.Items; -import net.minecraft.item.ItemStack; -import net.minecraft.nbt.NBTTagCompound; -import net.minecraftforge.common.util.ForgeDirection; -import net.minecraftforge.fluids.FluidStack; -import net.minecraftforge.fluids.IFluidHandler; - -public abstract class GregtechMetaBoilerBase extends GT_MetaTileEntity_BasicTank -{ - public int mTemperature = 20; - public int mProcessingEnergy = 0; - public int mLossTimer = 0; - public FluidStack mSteam = null; - public boolean mHadNoWater = false; - public long RI = MathUtils.randLong(5L, 30L); - - public GregtechMetaBoilerBase(int aID, String aName, String aNameRegional, String aDescription, ITexture... aTextures) - { - super(aID, aName, aNameRegional, 0, 4, aDescription, aTextures); - } - - public GregtechMetaBoilerBase(String aName, int aTier, String aDescription, ITexture[][][] aTextures) - { - super(aName, aTier, 4, aDescription, aTextures); - } - - public ITexture[] getTexture(IGregTechTileEntity aBaseMetaTileEntity, byte aSide, byte aFacing, byte aColorIndex, boolean aActive, boolean aRedstone) - { - ITexture[] tmp = mTextures[aSide >= 2 ? aSide != aFacing ? 2 : ((byte)(aActive ? 4 : 3)) : aSide][aColorIndex + 1]; - //mTextures[(aSide==aFacing?(aActive?4:3):aSide==GT_Utility.getOppositeSide(aFacing)?2:aSide==0?0:aSide==1?1:2)][aColorIndex+1]; - if(aSide!=aFacing&&tmp.length==2){ - tmp = new ITexture[]{tmp[0]}; - } - return tmp; - } - - public boolean isElectric() - { - return false; - } - - public boolean isPneumatic() - { - return false; - } - - public boolean isSteampowered() - { - return false; - } - - public boolean isSimpleMachine() - { - return false; - } - - public boolean isFacingValid(byte aFacing) - { - return aFacing > 1; - } - - public boolean isAccessAllowed(EntityPlayer aPlayer) - { - return true; - } - - public boolean isValidSlot(int aIndex) - { - return true; - } - - public int getProgresstime()