From facff8752dca52cce9a71739599034577b1334e8 Mon Sep 17 00:00:00 2001 From: bartimaeusnek <33183715+bartimaeusnek@users.noreply.github.com> Date: Mon, 3 Sep 2018 22:10:02 +0200 Subject: [PATCH] +added Large Essentia Gen +updated Single Block Solars and Single Block Essentia Gen to use @mitchej123 fix +added Large Essentia Gen support Blocks +added Super Nice Textures thanks to @LogicFalls +added Essentia Hatch +added Essentia Filler to support the Essentia Hatch --- src/main/java/emt/block/BlockMachines.java | 14 +- .../gthandler/common/blocks/EMT_GT_Block.java | 69 +++ .../common/implementations/EssentiaHatch.java | 176 ++++++++ .../automation/EssentiaFiller.java | 216 +++++++++ .../common/items/EMT_CasingBlock.java | 72 +++ .../common/loader/EMT_GT_Loader.java | 39 ++ .../generator/EMT_Large_Essentia_Gen.java | 415 ++++++++++++++++++ src/main/java/emt/init/EMTTiles.java | 4 +- src/main/java/emt/init/Registry.java | 7 +- .../emt/item/block/ItemBlockMachines.java | 21 +- .../generator/TileEntityBaseGenerator.java | 14 +- .../emt/tile/solar/TileEntitySolarBase.java | 8 + src/main/java/emt/util/EMTConfigHandler.java | 4 +- src/main/resources/assets/emt/lang/en_US.lang | 9 + .../emt/textures/blocks/machines/GT/inner.png | Bin 0 -> 1490 bytes .../textures/blocks/machines/GT/loader.png | Bin 0 -> 1093 bytes .../textures/blocks/machines/GT/rawcoreI.png | Bin 0 -> 1128 bytes .../textures/blocks/machines/GT/rawcoreII.png | Bin 0 -> 1602 bytes .../textures/blocks/machines/GT/siderawI.png | Bin 0 -> 1357 bytes .../textures/blocks/machines/GT/siderawII.png | Bin 0 -> 1683 bytes .../textures/blocks/machines/old/inner.png | Bin 0 -> 1141 bytes .../textures/blocks/machines/old/rawcoreI.png | Bin 0 -> 509 bytes .../blocks/machines/old/rawcoreII.png | Bin 0 -> 934 bytes .../emt/textures/blocks/machines/old/side.png | Bin 0 -> 1905 bytes .../textures/blocks/machines/old/siderawI.png | Bin 0 -> 620 bytes .../blocks/machines/old/siderawII.png | Bin 0 -> 970 bytes .../textures/blocks/machines/pdn/inner.pdn | Bin 0 -> 7799 bytes .../textures/blocks/machines/pdn/rawcoreI.pdn | Bin 0 -> 7290 bytes .../blocks/machines/pdn/rawcoreII.pdn | Bin 0 -> 9365 bytes .../emt/textures/blocks/machines/pdn/side.pdn | Bin 0 -> 7477 bytes .../textures/blocks/machines/pdn/siderawI.pdn | Bin 0 -> 7971 bytes .../blocks/machines/pdn/siderawII.pdn | Bin 0 -> 9331 bytes .../emt/textures/blocks/machines/side.png | Bin 1905 -> 1321 bytes src/main/resources/mcmod.info | 4 +- 34 files changed, 1060 insertions(+), 12 deletions(-) create mode 100644 src/main/java/emt/gthandler/common/blocks/EMT_GT_Block.java create mode 100644 src/main/java/emt/gthandler/common/implementations/EssentiaHatch.java create mode 100644 src/main/java/emt/gthandler/common/implementations/automation/EssentiaFiller.java create mode 100644 src/main/java/emt/gthandler/common/items/EMT_CasingBlock.java create mode 100644 src/main/java/emt/gthandler/common/loader/EMT_GT_Loader.java create mode 100644 src/main/java/emt/gthandler/common/tileentities/machines/multi/generator/EMT_Large_Essentia_Gen.java create mode 100644 src/main/resources/assets/emt/textures/blocks/machines/GT/inner.png create mode 100644 src/main/resources/assets/emt/textures/blocks/machines/GT/loader.png create mode 100644 src/main/resources/assets/emt/textures/blocks/machines/GT/rawcoreI.png create mode 100644 src/main/resources/assets/emt/textures/blocks/machines/GT/rawcoreII.png create mode 100644 src/main/resources/assets/emt/textures/blocks/machines/GT/siderawI.png create mode 100644 src/main/resources/assets/emt/textures/blocks/machines/GT/siderawII.png create mode 100644 src/main/resources/assets/emt/textures/blocks/machines/old/inner.png create mode 100644 src/main/resources/assets/emt/textures/blocks/machines/old/rawcoreI.png create mode 100644 src/main/resources/assets/emt/textures/blocks/machines/old/rawcoreII.png create mode 100644 src/main/resources/assets/emt/textures/blocks/machines/old/side.png create mode 100644 src/main/resources/assets/emt/textures/blocks/machines/old/siderawI.png create mode 100644 src/main/resources/assets/emt/textures/blocks/machines/old/siderawII.png create mode 100644 src/main/resources/assets/emt/textures/blocks/machines/pdn/inner.pdn create mode 100644 src/main/resources/assets/emt/textures/blocks/machines/pdn/rawcoreI.pdn create mode 100644 src/main/resources/assets/emt/textures/blocks/machines/pdn/rawcoreII.pdn create mode 100644 src/main/resources/assets/emt/textures/blocks/machines/pdn/side.pdn create mode 100644 src/main/resources/assets/emt/textures/blocks/machines/pdn/siderawI.pdn create mode 100644 src/main/resources/assets/emt/textures/blocks/machines/pdn/siderawII.pdn diff --git a/src/main/java/emt/block/BlockMachines.java b/src/main/java/emt/block/BlockMachines.java index 9a408f9..20c0b23 100644 --- a/src/main/java/emt/block/BlockMachines.java +++ b/src/main/java/emt/block/BlockMachines.java @@ -1,5 +1,6 @@ package emt.block; +import emt.gthandler.common.implementations.automation.EssentiaFiller; import ic2.api.item.IC2Items; import java.util.List; @@ -26,7 +27,7 @@ import emt.tile.TileEntityIndustrialWandRecharge; public class BlockMachines extends BlockBaseContainer { public BlockMachines(String name) { - super(name, Material.iron, soundTypeMetal, 2, 4.0F); + super(name, Material.iron, soundTypeMetal, 3, 4.0F); } @Override @@ -38,24 +39,30 @@ public class BlockMachines extends BlockBaseContainer { iconSets[0].top = ir.registerIcon(EMT.TEXTURE_PATH + ":machines/top"); iconSets[1].top = ir.registerIcon(EMT.TEXTURE_PATH + ":machines/etherealmaceratortop"); + iconSets[2].top = ir.registerIcon(EMT.TEXTURE_PATH + ":machines/etherealmaceratortop"); iconSets[0].bottom = ir.registerIcon(EMT.TEXTURE_PATH + ":machines/side"); iconSets[1].bottom = ir.registerIcon(EMT.TEXTURE_PATH + ":machines/etherealmacerator"); + iconSets[2].bottom = ir.registerIcon(EMT.TEXTURE_PATH + ":machines/etherealmaceratortop"); iconSets[0].side = ir.registerIcon(EMT.TEXTURE_PATH + ":machines/side"); iconSets[1].side = ir.registerIcon(EMT.TEXTURE_PATH + ":machines/etherealmacerator"); + iconSets[2].side = ir.registerIcon(EMT.TEXTURE_PATH + ":machines/etherealmaceratortop"); iconSets[0].frontOff = ir.registerIcon(EMT.TEXTURE_PATH + ":machines/wandcharger"); iconSets[1].frontOff = ir.registerIcon(EMT.TEXTURE_PATH + ":machines/etherealmaceratorfront"); + iconSets[2].frontOff = ir.registerIcon(EMT.TEXTURE_PATH + ":machines/etherealmaceratortop"); iconSets[0].frontOn = ir.registerIcon(EMT.TEXTURE_PATH + ":machines/wandcharger"); iconSets[1].frontOn = ir.registerIcon(EMT.TEXTURE_PATH + ":machines/etherealmaceratorfrontactive"); + iconSets[2].frontOn = ir.registerIcon(EMT.TEXTURE_PATH + ":machines/etherealmaceratortop"); } @SideOnly(Side.CLIENT) public void getSubBlocks(Item id, CreativeTabs tab, List list) { list.add(new ItemStack(id, 1, 0)); list.add(new ItemStack(id, 1, 1)); + list.add(new ItemStack(id, 1, 2)); } @Override @@ -63,9 +70,12 @@ public class BlockMachines extends BlockBaseContainer { if (meta == 0) { return new TileEntityIndustrialWandRecharge(); } - if (meta == 1) { + else if (meta == 1) { return new TileEntityEtherealMacerator(); } + else if (meta == 2){ + return new EssentiaFiller(); + } return super.createTileEntity(world, meta); } diff --git a/src/main/java/emt/gthandler/common/blocks/EMT_GT_Block.java b/src/main/java/emt/gthandler/common/blocks/EMT_GT_Block.java new file mode 100644 index 0000000..47ddb7e --- /dev/null +++ b/src/main/java/emt/gthandler/common/blocks/EMT_GT_Block.java @@ -0,0 +1,69 @@ +package emt.gthandler.common.blocks; + +import cpw.mods.fml.relauncher.Side; +import cpw.mods.fml.relauncher.SideOnly; +import emt.EMT; +import net.minecraft.block.Block; +import net.minecraft.block.material.Material; +import net.minecraft.client.renderer.texture.IIconRegister; +import net.minecraft.creativetab.CreativeTabs; +import net.minecraft.item.Item; +import net.minecraft.item.ItemStack; +import net.minecraft.util.IIcon; + +import java.util.List; + +public class EMT_GT_Block extends Block { + + public EMT_GT_Block(String name, String[] texture) { + super(Material.anvil); + this.setHardness(15.0F); + this.setResistance(30.0F); + this.name = name; + this.textureNames=texture; + this.setCreativeTab(EMT.TAB); + } + + @SideOnly(Side.CLIENT) + private static IIcon[] texture; + @SideOnly(Side.CLIENT) + private String[] textureNames; + private String name; + + @Override + public int damageDropped(final int meta) { + return meta; + } + + @Override + public void getSubBlocks(final Item item, final CreativeTabs tab, final List list) { + for (int i = 0; i < textureNames.length; i ++) { + list.add(new ItemStack(item, 1, i)); + } + } + + @Override + @SideOnly(Side.CLIENT) + public IIcon getIcon(int side, int meta) { + return meta < texture.length ? texture[meta] : texture[1]; + } + + @Override + @SideOnly(Side.CLIENT) + public void registerBlockIcons(IIconRegister par1IconRegister){ + texture = new IIcon[textureNames.length]; + for (int i = 0; i < textureNames.length; i++) { + texture[i] = par1IconRegister.registerIcon(textureNames[i]); + } + } + + @Override + public boolean isOpaqueCube() { + return false; + } + + @Override + public String getUnlocalizedName(){ + return name; + } +} diff --git a/src/main/java/emt/gthandler/common/implementations/EssentiaHatch.java b/src/main/java/emt/gthandler/common/implementations/EssentiaHatch.java new file mode 100644 index 0000000..687fd88 --- /dev/null +++ b/src/main/java/emt/gthandler/common/implementations/EssentiaHatch.java @@ -0,0 +1,176 @@ +package emt.gthandler.common.implementations; + +import gregtech.api.enums.GT_Values; +import gregtech.api.gui.GT_Container; +import gregtech.api.gui.GT_GUIContainer; +import gregtech.api.interfaces.ITexture; +import gregtech.api.interfaces.tileentity.IGregTechTileEntity; +import gregtech.api.metatileentity.MetaTileEntity; +import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_Hatch_Input; +import gregtech.api.util.GT_Utility; +import net.minecraft.entity.player.InventoryPlayer; +import net.minecraft.item.ItemStack; +import net.minecraft.nbt.NBTTagCompound; +import net.minecraft.nbt.NBTTagList; +import net.minecraftforge.fluids.FluidStack; +import thaumcraft.api.aspects.Aspect; +import thaumcraft.api.aspects.AspectList; + +import java.util.ArrayList; + + +public class EssentiaHatch extends GT_MetaTileEntity_Hatch_Input { + + private AspectList current = new AspectList(); + private static int ApTe = (int) Math.ceil(Aspect.aspects.size()/GT_Values.V.length); + + public boolean addAspectList(final AspectList A){ + + if ((this.mTier+1)*ApTe > A.size()+current.size()){ + if (current.visSize() + A.visSize() < (this.mTier+1)*ApTe*64) + current.add(A); + return true; + }else + return false; + + } + + public EssentiaHatch(int aID, String aName, String aNameRegional, int aTier) { + super(aID, aName, aNameRegional, aTier); + } + + public EssentiaHatch(String aName, int aTier, String aDescription, ITexture[][][] aTextures) { + super(aName, aTier, aDescription, aTextures); + } + + public EssentiaHatch(String aName, int aTier, String[] aDescription, ITexture[][][] aTextures) { + super(aName, aTier, aDescription, aTextures); + } + + public void setCurrent(AspectList List){ + this.current = List; + } + + public AspectList getAspects() { + return current; + } + + public MetaTileEntity newMetaEntity(IGregTechTileEntity aTileEntity) { + return new EssentiaHatch("Essentia Hatch "+ GT_Values.VN[this.mTier],this.mTier,this.getDescription(),this.mTextures); + } + + + @Override + public Object getClientGUI(int aID, InventoryPlayer aPlayerInventory, IGregTechTileEntity aBaseMetaTileEntity) { + //TODO: new GUI. + return null; + } + + @Override + public Object getServerGUI(int aID, InventoryPlayer aPlayerInventory, IGregTechTileEntity aBaseMetaTileEntity) { + //TODO: new contanier GUI. + return null; + } + + @Override + public String[] getInfoData() { + ArrayList list = new ArrayList(); + list.add("This Essentia-Hatch contains:"); + for (final Aspect A : this.current.aspects.keySet()) + list.add(A.getName()+": "+Integer.toString(current.getAmount(A))); + + String[] ret = new String[list.size()]; + for (int i = 0; i < list.size(); i++) { + ret[i]=list.get(i); + } + + return ret; + + /*String[] old = super.getInfoData(); + if (old.length!=0) { + String[] newDescription = new String[old.length + 1]; + for (int i = 0; i < old.length; i++) { + newDescription[i] = old[i]; + } + newDescription[old.length] = "This Contains: " + current.size() + " different Aspects"; + return newDescription; + }else + return new String[]{"This Contains: " + current.size() + " different Aspects"};*/ + } + + @Override + public String[] getDescription(){ //this is the fucking tooltip -_-' + return new String[] { + "Essentia Hatch for usage in Multiblocks", + "Can only be filled with the Essentia Filler", + "Can hold "+Integer.toString((ApTe*(mTier+1)))+" Different Essentia Types", + "Can hold "+Integer.toString((64*ApTe*(mTier+1)))+" Essentia in total" + }; + } + + @Override + public boolean isGivingInformation() { + return true; + } + + @Override + public void saveNBTData(NBTTagCompound var1){ + + NBTTagList tlist = new NBTTagList(); + var1.setTag("Aspects", tlist); + Aspect[] aspectA = current.getAspects(); + + for(int i = 0; i < aspectA.length; ++i) { + Aspect aspect = aspectA[i]; + if (aspect != null) { + NBTTagCompound f = new NBTTagCompound(); + f.setString("key", aspect.getTag()); + f.setInteger("amount", current.getAmount(aspect)); + tlist.appendTag(f); + } + } + + super.saveNBTData(var1); + } + + @Override + public void loadNBTData(NBTTagCompound var1){ + current = new AspectList(); + NBTTagList tlist = var1.getTagList("Aspects", 10); + + for(int j = 0; j < tlist.tagCount(); ++j) { + NBTTagCompound rs = tlist.getCompoundTagAt(j); + if (rs.hasKey("key")) { + current.add(Aspect.getAspect(rs.getString("key")), rs.getInteger("amount")); + } + } + + super.loadNBTData(var1); + } + + public int fuelleft() { + int ret = 0; + for (final Aspect A : current.aspects.keySet()){ + ret += current.getAmount(A); + } + return ret; + } + + + public boolean isFluidInputAllowed(FluidStack aFluid) { + return false; + } + + public boolean allowPullStack(IGregTechTileEntity aBaseMetaTileEntity, int aIndex, byte aSide, ItemStack aStack) { + return false; + } + + public boolean allowPutStack(IGregTechTileEntity aBaseMetaTileEntity, int aIndex, byte aSide, ItemStack aStack) { + return false; + } + + public int getCapacity() { + return 0; + } + +} diff --git a/src/main/java/emt/gthandler/common/implementations/automation/EssentiaFiller.java b/src/main/java/emt/gthandler/common/implementations/automation/EssentiaFiller.java new file mode 100644 index 0000000..50cb8c2 --- /dev/null +++ b/src/main/java/emt/gthandler/common/implementations/automation/EssentiaFiller.java @@ -0,0 +1,216 @@ +package emt.gthandler.common.implementations.automation; + +import emt.gthandler.common.implementations.EssentiaHatch; +import emt.tile.TileEntityEMT; +import gregtech.api.interfaces.metatileentity.IMetaTileEntity; +import gregtech.api.interfaces.tileentity.IGregTechTileEntity; +import net.minecraft.tileentity.TileEntity; +import net.minecraftforge.common.util.ForgeDirection; +import thaumcraft.api.ThaumcraftApiHelper; +import thaumcraft.api.aspects.Aspect; +import thaumcraft.api.aspects.AspectList; +import thaumcraft.api.aspects.IAspectContainer; +import thaumcraft.api.aspects.IEssentiaTransport; + +import java.util.ArrayList; + +public class EssentiaFiller extends TileEntityEMT implements IAspectContainer, IEssentiaTransport { + + private AspectList current = new AspectList(); + private byte tick = 0; + + @Override + public void updateEntity(){ + ++tick; + fillfrompipe(); + if (tick %20 == 0){ + TileEntity T = this.worldObj.getTileEntity(xCoord,yCoord+1,zCoord); + if (checkTE(T)){ + tick = 0; + return; + } + if (T == null) + T = this.worldObj.getTileEntity(xCoord+1,yCoord,zCoord); + if (checkTE(T)) { + tick = 0; + return; + } + if (T == null) + T = this.worldObj.getTileEntity(xCoord,yCoord,zCoord+1); + if (checkTE(T)) { + tick = 0; + return; + } + if (T == null) + T = this.worldObj.getTileEntity(xCoord,yCoord-1,zCoord); + if (checkTE(T)) { + tick = 0; + return; + } + if (T == null) + T = this.worldObj.getTileEntity(xCoord-1,yCoord,zCoord); + if (checkTE(T)) { + tick = 0; + return; + } + if (T == null) + T = this.worldObj.getTileEntity(xCoord,yCoord,zCoord-1); + if (checkTE(T)) { + tick = 0; + return; + } + } + } + + private boolean checkTE(final TileEntity T){ + if (T == null) + return false; + if (this.current.visSize() > 0) + if (T instanceof IGregTechTileEntity) { + IMetaTileEntity M = ((IGregTechTileEntity) T).getMetaTileEntity(); + if (M instanceof EssentiaHatch){ + if (((EssentiaHatch)M).addAspectList(current)) + this.current=new AspectList(); + return true; + } + } + + return false; + } + + public void fillfrompipe() + { + TileEntity[] te = new TileEntity[ForgeDirection.VALID_DIRECTIONS.length]; + for (int i = 0; i < ForgeDirection.VALID_DIRECTIONS.length; i++) + { + te[i] = ThaumcraftApiHelper.getConnectableTile(this.worldObj, this.xCoord, this.yCoord, this.zCoord, ForgeDirection.VALID_DIRECTIONS[i]); + if (te[i] != null) + { + IEssentiaTransport pipe = (IEssentiaTransport)te[i]; + if (!pipe.canOutputTo(ForgeDirection.VALID_DIRECTIONS[i])) { + return; + } + if ((pipe.getEssentiaType(ForgeDirection.VALID_DIRECTIONS[i]) != null) && (pipe.getSuctionAmount(ForgeDirection.VALID_DIRECTIONS[i]) < getSuctionAmount(ForgeDirection.VALID_DIRECTIONS[i]))) { + addToContainer(pipe.getEssentiaType(ForgeDirection.VALID_DIRECTIONS[i]), pipe.takeEssentia(pipe.getEssentiaType(ForgeDirection.VALID_DIRECTIONS[i]), 1, ForgeDirection.VALID_DIRECTIONS[i])); + } + } + } + } + + @Override + public AspectList getAspects() { + return current; + } + + @Override + public void setAspects(AspectList aspectList) { + this.current.add(aspectList); + } + + @Override + public boolean doesContainerAccept(Aspect aspect) { + return true; + } + + @Override + public int addToContainer(Aspect aspect, int i) { + current.add(aspect,i); + return 0; + } + + @Override + public boolean takeFromContainer(Aspect aspect, int i) { + return false; + } + + @Override + public boolean takeFromContainer(AspectList aspectList) { + return false; + } + + @Override + public boolean doesContainerContainAmount(Aspect aspect, int i) { + return current.aspects.containsKey(aspect) && i <= current.getAmount(aspect); + } + + @Override + public boolean doesContainerContain(AspectList aspectList) { + ArrayList ret = new ArrayList(); + for (Aspect a : aspectList.aspects.keySet()) + if (current.aspects.containsKey(a)) { + ret.add(true); + }else + ret.add(false); + return !ret.contains(false); + } + + @Override + public int containerContains(Aspect aspect) { + return current.aspects.containsKey(aspect) ? current.getAmount(aspect) : 0; + } + + @Override + public boolean isConnectable(ForgeDirection forgeDirection) { + return true; + } + + @Override + public boolean canInputFrom(ForgeDirection forgeDirection) { + return true; + } + + @Override + public boolean canOutputTo(ForgeDirection forgeDirection) { + return false; + } + + @Override + public void setSuction(Aspect aspect, int i) { + + } + + @Override + public Aspect getSuctionType(ForgeDirection forgeDirection) { + return null; + } + + @Override + public int getSuctionAmount(ForgeDirection forgeDirection) { + return 256; + } + + @Override + public int takeEssentia(Aspect aspect, int i, ForgeDirection forgeDirection) { + return 0; + } + + @Override + public int addEssentia(Aspect aspect, int i, ForgeDirection forgeDirection) { + current.add(aspect,i); + return 0; + } + + @Override + public Aspect getEssentiaType(ForgeDirection forgeDirection) { + return current.getAspects()[0]; + } + + @Override + public int getEssentiaAmount(ForgeDirection forgeDirection) { + int ret = 0; + for (final Aspect A : current.aspects.keySet()){ + ret += current.getAmount(A); + } + return ret; + } + + @Override + public int getMinimumSuction() { + return Integer.MAX_VALUE; + } + + @Override + public boolean renderExtendedTube() { + return true; + } +} diff --git a/src/main/java/emt/gthandler/common/items/EMT_CasingBlock.java b/src/main/java/emt/gthandler/common/items/EMT_CasingBlock.java new file mode 100644 index 0000000..4cfde21 --- /dev/null +++ b/src/main/java/emt/gthandler/common/items/EMT_CasingBlock.java @@ -0,0 +1,72 @@ +package emt.gthandler.common.items; + +import cpw.mods.fml.relauncher.Side; +import cpw.mods.fml.relauncher.SideOnly; +import emt.EMT; +import emt.gthandler.common.blocks.EMT_GT_Block; +import gregtech.api.util.GT_LanguageManager; +import net.minecraft.block.Block; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.item.ItemBlock; +import net.minecraft.item.ItemStack; +import net.minecraft.util.IIcon; + +import java.util.List; + +public class EMT_CasingBlock extends ItemBlock { + + public static final Block[] EMT_GT_BLOCKS = {new EMT_GT_Block("EMT_GTBLOCK_CASEING", new String[] + { + EMT.TEXTURE_PATH+":machines/side", + EMT.TEXTURE_PATH+":machines/GT/inner", + EMT.TEXTURE_PATH+":machines/GT/siderawI", + EMT.TEXTURE_PATH+":machines/GT/rawcoreI", + EMT.TEXTURE_PATH+":machines/GT/siderawII", + EMT.TEXTURE_PATH+":machines/GT/rawcoreII", + } + )}; + + public EMT_CasingBlock(final Block par1){ + super(par1); + this.setMaxDamage(0); + this.setHasSubtypes(true); + this.setCreativeTab(EMT.TAB); + } + + protected final String mNoMobsToolTip = GT_LanguageManager.addStringLocalization("gt.nomobspawnsonthisblock", "Mobs cannot Spawn on this Block"); + protected final String mNoTileEntityToolTip = GT_LanguageManager.addStringLocalization("gt.notileentityinthisblock", "This is NOT a TileEntity!"); + + @Override + public int getMetadata(final int aMeta) { + return aMeta; + } + + @Override + public String getUnlocalizedName(final ItemStack aStack) { + return this.field_150939_a.getUnlocalizedName() + "." + this.getDamage(aStack); + } + + @Override + public void addInformation(final ItemStack aStack, final EntityPlayer aPlayer, final List aList, final boolean aF3_H) { + aList.add(this.mNoMobsToolTip); + aList.add(this.mNoTileEntityToolTip); + } + + @Override + @SideOnly(Side.CLIENT) + public IIcon getIcon(ItemStack stack, int pass) { + return this.field_150939_a.getIcon(0,stack.getItemDamage()); + } + + @Override + @SideOnly(Side.CLIENT) + public IIcon getIcon(ItemStack stack, int renderPass, EntityPlayer player, ItemStack usingItem, int useRemaining) { + return getIcon(stack, renderPass); + } + + @Override + @SideOnly(Side.CLIENT) + public IIcon getIconFromDamageForRenderPass(int p_77618_1_, int p_77618_2_) { + return this.field_150939_a.getIcon(0,p_77618_2_); + } +} diff --git a/src/main/java/emt/gthandler/common/loader/EMT_GT_Loader.java b/src/main/java/emt/gthandler/common/loader/EMT_GT_Loader.java new file mode 100644 index 0000000..30b0220 --- /dev/null +++ b/src/main/java/emt/gthandler/common/loader/EMT_GT_Loader.java @@ -0,0 +1,39 @@ +package emt.gthandler.common.loader; + +import cpw.mods.fml.common.registry.GameRegistry; +import emt.gthandler.common.implementations.EssentiaHatch; +import emt.gthandler.common.items.EMT_CasingBlock; +import emt.gthandler.common.tileentities.machines.multi.generator.EMT_Large_Essentia_Gen; +import gregtech.api.enums.GT_Values; +import gregtech.api.enums.ItemList; +import gregtech.api.enums.Materials; +import gregtech.api.enums.OrePrefixes; +import gregtech.api.util.GT_ModHandler; +import gregtech.api.util.GT_OreDictUnificator; +import net.minecraft.item.ItemStack; +import thaumcraft.common.config.ConfigBlocks; +import thaumcraft.common.config.ConfigItems; + +public class EMT_GT_Loader implements Runnable { + + + public static final int TIERS = GT_Values.VN.length; + public static int aIDoffset = 13000-TIERS-1; + public static ItemStack[] EHatch = new ItemStack[TIERS]; + public static ItemStack LEG; + @Override + public void run() { + + for (int i = 0; i < TIERS; i++) { + EHatch[i] = new EssentiaHatch(aIDoffset+i,"Essentia Hatch "+ GT_Values.VN[i],"Essentia Hatch "+ GT_Values.VN[i],i).getStackForm(1L); + } + GameRegistry.registerBlock(EMT_CasingBlock.EMT_GT_BLOCKS[0],EMT_CasingBlock.class,"EMT_GTBLOCK_CASEING"); + LEG = new EMT_Large_Essentia_Gen(aIDoffset+TIERS+1,"Large Essentia Generator","Large Essentia Generator").getStackForm(1L); + GT_Values.RA.addAssemblerRecipe(new ItemStack[]{GT_OreDictUnificator.get(OrePrefixes.frameGt,Materials.Indium,1L),GT_OreDictUnificator.get(OrePrefixes.stickLong,Materials.Tungsten,4L)},Materials.SolderingAlloy.getMolten(576L), new ItemStack(EMT_CasingBlock.EMT_GT_BLOCKS[0],1,3),100, (int)(GT_Values.V[5]-(GT_Values.V[5]/10))); + GT_Values.RA.addAssemblerRecipe(new ItemStack[]{new ItemStack(EMT_CasingBlock.EMT_GT_BLOCKS[0],1,3),GT_OreDictUnificator.get(OrePrefixes.plate,Materials.Iridium,8L)},Materials.Osmiridium.getMolten(576L), new ItemStack(EMT_CasingBlock.EMT_GT_BLOCKS[0],1,5),100, (int)(GT_Values.V[5]-(GT_Values.V[5]/10))); + GT_Values.RA.addAssemblerRecipe(new ItemStack[]{GT_OreDictUnificator.get(OrePrefixes.frameGt,Materials.Iridium,1L),GT_OreDictUnificator.get(OrePrefixes.stickLong,Materials.Osmiridium,4L)},Materials.SolderingAlloy.getMolten(576L), new ItemStack(EMT_CasingBlock.EMT_GT_BLOCKS[0],1,2),100, (int)(GT_Values.V[5]-(GT_Values.V[5]/10))); + GT_Values.RA.addAssemblerRecipe(new ItemStack[]{new ItemStack(EMT_CasingBlock.EMT_GT_BLOCKS[0],1,2), GT_ModHandler.getModItem("ThaumicTinkerer","ichorium",2L)},Materials.Concrete.getMolten(2304L), new ItemStack(EMT_CasingBlock.EMT_GT_BLOCKS[0],1,4),100, (int)(GT_Values.V[5]-(GT_Values.V[5]/10))); + for (int i = 0; i < ItemList.HATCHES_INPUT.length; i++) + GT_Values.RA.addAssemblerRecipe(new ItemStack[]{ItemList.HATCHES_INPUT[i].get(1L), new ItemStack(ConfigBlocks.blockTube,1,1)},Materials.Thaumium.getMolten(288L),EHatch[i],100,(int)(GT_Values.V[i]-(GT_Values.V[i]/10))); + } +} diff --git a/src/main/java/emt/gthandler/common/tileentities/machines/multi/generator/EMT_Large_Essentia_Gen.java b/src/main/java/emt/gthandler/common/tileentities/machines/multi/generator/EMT_Large_Essentia_Gen.java new file mode 100644 index 0000000..de4b759 --- /dev/null +++ b/src/main/java/emt/gthandler/common/tileentities/machines/multi/generator/EMT_Large_Essentia_Gen.java @@ -0,0 +1,415 @@ +package emt.gthandler.common.tileentities.machines.multi.generator; + +import emt.gthandler.common.implementations.EssentiaHatch; +import emt.gthandler.common.items.EMT_CasingBlock; +import emt.util.EMTEssentiasOutputs; +import emt.util.EMTTextHelper; +import gregtech.api.enums.Materials; +import gregtech.api.enums.Textures; +import gregtech.api.interfaces.ITexture; +import gregtech.api.interfaces.metatileentity.IMetaTileEntity; +import gregtech.api.interfaces.tileentity.IGregTechTileEntity; +import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_MultiBlockBase; +import gregtech.api.objects.GT_RenderedTexture; +import gregtech.api.objects.XSTR; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.item.ItemStack; +import net.minecraft.world.World; +import net.minecraftforge.common.util.ForgeDirection; +import thaumcraft.api.aspects.Aspect; +import thaumcraft.api.aspects.AspectList; +import thaumcraft.api.visnet.VisNetHandler; +import thaumcraft.common.config.ConfigBlocks; + +import java.util.ArrayList; + +public class EMT_Large_Essentia_Gen extends GT_MetaTileEntity_MultiBlockBase { + + public ArrayList mEssentiaHatches = new ArrayList(); + private static final byte CASING_INDEX = 2; + private byte tick = 0; + private boolean has_lube = false; + + public EMT_Large_Essentia_Gen(int aID, String aName, String aNameRegional) { + super(aID, aName, aNameRegional); + } + + public EMT_Large_Essentia_Gen(String aName) { + super(aName); + } + + @Override + public String[] getDescription() { + return new String[]{ + "Controller Block for the Large Essentia Generator.", + "Produces energy from magical essentia decay.", + "Size(WxHxD): 7x4x7, Controller (Bottom, Center)", + "Top-Middle 5x1x5 layer are Muffler Hatches", + "Middle 5x3x5 layer are Essentia Diffusion Cells", + "Everything from here on goes either in the bottom or on the sides", + "1x Fluid Input Hatch", + "1x Essentia Input Hatch", + "1x Dynamo Hatches", + "1x Maintenance Hatch", + "Rest is made out of Magic Containing Casings", + "Produces 20x more than the singleblock per essentia", + "Causes magical and serious conventional pollution", + "Needs 1L Lubricant per second or will cause way more conventional pollution", + "Needs 10 " + EMTTextHelper.LIGHT_BLUE +"Aqua"+ EMTTextHelper.LIGHT_GRAY +" cVis per second or will cause way more magical pollution", + "Added by EMT", + "Made by bartimaeusnek" + }; + } + + public int getCurrentEfficiency(ItemStack itemStack) { + return this.mEfficiency - (this.getIdealStatus() - this.getRepairStatus()) * this.getMaxEfficiency(itemStack) / 10; + } + + @Override + public ITexture[] getTexture(IGregTechTileEntity aBaseMetaTileEntity, byte aSide, byte aFacing, byte aColorIndex, boolean aActive, boolean aRedstone){ + if (aSide == aFacing) { + return new ITexture[]{Textures.BlockIcons.CASING_BLOCKS[CASING_INDEX], new GT_RenderedTexture(aActive ? Textures.BlockIcons.OVERLAY_FRONT_DISTILLATION_TOWER_ACTIVE : Textures.BlockIcons.OVERLAY_FRONT_DISTILLATION_TOWER)}; + } + return new ITexture[]{Textures.BlockIcons.CASING_BLOCKS[CASING_INDEX]}; + } + + @Override + public IMetaTileEntity newMetaEntity(IGregTechTileEntity arg0) { + return new EMT_Large_Essentia_Gen(this.mName); + } + + @Override + public int[] getAccessibleSlotsFromSide(int p_94128_1_) { + // TODO Auto-generated method stub + return new int[0]; + } + + @Override + public boolean canInsertItem(int p_102007_1_, ItemStack p_102007_2_, int p_102007_3_) { + // TODO Auto-generated method stub + return false; + } + + @Override + public boolean canExtractItem(int p_102008_1_, ItemStack p_102008_2_, int p_102008_3_) { + // TODO Auto-generated method stub + return false; + } + + @Override + public int getSizeInventory() { + return 0; + } + + @Override + public ItemStack getStackInSlot(int p_70301_1_) { + // TODO Auto-generated method stub + return null; + } + + @Override + public ItemStack decrStackSize(int p_70298_1_, int p_70298_2_) { + // TODO Auto-generated method stub + return null; + } + + @Override + public ItemStack getStackInSlotOnClosing(int p_70304_1_) { + // TODO Auto-generated method stub + return null; + } + + @Override + public void setInventorySlotContents(int p_70299_1_, ItemStack p_70299_2_) { + // TODO Auto-generated method stub + + } + + @Override + public String getInventoryName() { + // TODO Auto-generated method stub + return this.mName; + } + + @Override + public boolean hasCustomInventoryName() { + // TODO Auto-generated method stub + return true; + } + + @Override + public int getInventoryStackLimit() { + // TODO Auto-generated method stub + return 0; + } + + @Override + public void markDirty() { + // TODO Auto-generated method stub + + } + + @Override + public boolean isUseableByPlayer(EntityPlayer p_70300_1_) { + // TODO Auto-generated method stub + return true; + } + + @Override + public void openInventory() { + // TODO Auto-generated method stub + + } + + @Override + public void closeInventory() { + // TODO Auto-generated method stub + + } + + @Override + public boolean isItemValidForSlot(int p_94041_1_, ItemStack p_94041_2_) { + // TODO Auto-generated method stub + return false; + } + + @Override + public boolean checkMachine(IGregTechTileEntity aBaseMetaTileEntity, ItemStack arg1) { + + final int xDir = ForgeDirection.getOrientation(aBaseMetaTileEntity.getBackFacing()).offsetX * 3; + final int zDir = ForgeDirection.getOrientation(aBaseMetaTileEntity.getBackFacing()).offsetZ * 3; + + for (int x = -3; x <= 3; x++) { + for (int z = -3; z <= 3; z++) { + for (int h = 0; h <= 3; h++) { + final IGregTechTileEntity tTileEntity = aBaseMetaTileEntity.getIGregTechTileEntityOffset(xDir + x, h, zDir + z); + + if (!((x == -3) || (x == 3) || (z == -3) || (z == 3))) { + // Muffler on top. + if ((h == 3)) { + if (!this.addMufflerToMachineList(tTileEntity, CASING_INDEX)) { + return false; + } + } else if (h != 0) { + //inside Special Blocks + if (aBaseMetaTileEntity.getBlockOffset(xDir + x, h, zDir + z) != EMT_CasingBlock.EMT_GT_BLOCKS[0]) + return false; + else if ((aBaseMetaTileEntity.getMetaIDOffset(xDir + x, h, zDir + z) != 1)) + return false; + } + else + if (!(this.addEssetiaHatchToList(tTileEntity,CASING_INDEX)||this.addDynamoToMachineList(tTileEntity,CASING_INDEX)||this.addMaintenanceToMachineList(tTileEntity,CASING_INDEX)||this.addInputToMachineList(tTileEntity,CASING_INDEX))) + //ground still casings + if (aBaseMetaTileEntity.getBlockOffset(xDir + x, h, zDir + z) != EMT_CasingBlock.EMT_GT_BLOCKS[0]) + return false; + else if ((aBaseMetaTileEntity.getMetaIDOffset(xDir + x, h, zDir + z) != 0)) + return false; + + } + else if (h != 0) { + //walls + if (!(this.addEssetiaHatchToList(tTileEntity,CASING_INDEX)||this.addDynamoToMachineList(tTileEntity,CASING_INDEX)||this.addMaintenanceToMachineList(tTileEntity,CASING_INDEX)||this.addInputToMachineList(tTileEntity,CASING_INDEX))) + if (aBaseMetaTileEntity.getBlockOffset(xDir + x, h, zDir + z) != EMT_CasingBlock.EMT_GT_BLOCKS[0]) + return false; + else if ((aBaseMetaTileEntity.getMetaIDOffset(xDir + x, h, zDir + z) != 0)) + return false; + } + else if (h == 0 ){ + //top and bottom corners + if (!(this.addEssetiaHatchToList(tTileEntity,CASING_INDEX)||this.addDynamoToMachineList(tTileEntity,CASING_INDEX)||this.addMaintenanceToMachineList(tTileEntity,CASING_INDEX)||this.addInputToMachineList(tTileEntity,CASING_INDEX))) + if (((xDir + x) != 0) || ((zDir + z) != 0)) //controller + if (aBaseMetaTileEntity.getBlockOffset(xDir + x, h, zDir + z) != EMT_CasingBlock.EMT_GT_BLOCKS[0]) + return false; + else if ((aBaseMetaTileEntity.getMetaIDOffset(xDir + x, h, zDir + z) != 0)) + return false; + } + + } + } + } + + if (this.mDynamoHatches.size() != 1) + return false; + + if (this.mInputHatches.size() != 1) + return false; + + if (this.mMaintenanceHatches.size() != 1) + return false; + + //repair shit debug shit + this.mWrench = true; + this.mScrewdriver = true; + this.mSoftHammer = true; + this.mHardHammer = true; + this.mSolderingTool = true; + this.mCrowbar = true; + + return true; + } + + private boolean addEssetiaHatchToList(IGregTechTileEntity aTileEntity, int aBaseCasingIndex){ + if (aTileEntity == null) { + return false; + } else { + IMetaTileEntity aMetaTileEntity = aTileEntity.getMetaTileEntity(); + if (aMetaTileEntity == null) { + return false; + } else if (aMetaTileEntity instanceof EssentiaHatch) { + ((EssentiaHatch)aMetaTileEntity).updateTexture(aBaseCasingIndex); + return this.mEssentiaHatches.add((EssentiaHatch)aMetaTileEntity); + } else { + return false; + } + } + } + + + private void make_energy(){ + AspectList fuel = this.mEssentiaHatches.get(0).getAspects(); + double cached = 0; + + ++tick; + + //make energy + for (final Aspect A : fuel.aspects.keySet()) { + if (fuel.getAmount(A) > 0 ) { + double burnvalue = EMTEssentiasOutputs.outputs.get(A.getTag()).doubleValue(); + cached += (burnvalue / 20D); + cached = Math.ceil(cached); + + if (tick % 20 == 0) { //every second consume 1 essentia + //consume essentia and remove it from the Aspect List if its 0 + this.mEssentiaHatches.get(0).getAspects().reduce(A, 1); + if (this.mEssentiaHatches.get(0).getAspects().getAmount(A)==0) + this.mEssentiaHatches.get(0).getAspects().remove(A); + } + } + } + + if (tick % 20 == 0){ + //consume lubricant + if (has_lube) + this.mInputHatches.get(0).getFluid().amount -= 1; + + tick = 0; //reset ticktimer + } + + //transfer energy into mEU + this.mEUt = (int) cached; + } + + @Override + public boolean checkRecipe(ItemStack arg0) { + /* + if (!this.getBaseMetaTileEntity().isActive()) + if (this.mEfficiency > 100) + this.mEfficiency -= 8; + else + this.mEfficiency = 100; + */ + if (this.mEssentiaHatches.get(0).fuelleft() > 0){ + this.mMaxProgresstime=1; + this.mProgresstime=0; + } + + return this.mEssentiaHatches.get(0).fuelleft() > 0; + } + + @Override + public boolean onRunningTick(ItemStack aStack) { + + if (tick % 20 == 0) {//every second + //highers eff to max by 0.16% every running tick = 3,2% every second + if (this.mEfficiency < this.getMaxEfficiency(null) - 320) + this.mEfficiency += 320; + else + this.mEfficiency = getMaxEfficiency(null); + + //check for Lubricant + this.has_lube = this.mInputHatches.get(0).getFluid() != null && this.mInputHatches.get(0).getFluid().isFluidEqual(Materials.Lubricant.getFluid(1L)) && this.mInputHatches.get(0).getFluidAmount() > 0; + } + + + if (tick % 2 == 0) {//every 2nd tick + + final XSTR R = new XSTR(); + final World WORLD=this.getBaseMetaTileEntity().getWorld(); + int x = this.getBaseMetaTileEntity().getXCoord(); + int y = this.getBaseMetaTileEntity().getYCoord(); + int z = this.getBaseMetaTileEntity().getZCoord(); + + //if out of aqua, make much flux but to not stop. + boolean outOfcVis = VisNetHandler.drainVis(WORLD, x, y, z, Aspect.WATER, 10) <= 9; + + //Random Change of a bit of Flux Gas. + final int RANDOMHATCH = R.nextInt(this.mMufflerHatches.size()); + + //gets a chanche to release flux gas based on missing efficiency, min 1% + if ((R.nextInt(getMaxEfficiency(null)) > (this.mEfficiency > 100 ? this.mEfficiency : 100)) || outOfcVis) { + x = this.mMufflerHatches.get(RANDOMHATCH).getBaseMetaTileEntity().getXCoord(); + y = this.mMufflerHatches.get(RANDOMHATCH).getBaseMetaTileEntity().getYCoord() + 1; + z = this.mMufflerHatches.get(RANDOMHATCH).getBaseMetaTileEntity().getZCoord(); + WORLD.setBlock(x, y, z, ConfigBlocks.blockFluxGas, R.nextInt(8), 3); + } + } + + make_energy(); + ++this.mProgresstime; + return super.onRunningTick(aStack); + } + + @Override + public boolean explodesOnComponentBreak(ItemStack arg0) { + return false; + } + + @Override + public int getDamageToComponent(ItemStack arg0) { + // TODO Auto-generated method stub + return 0; + } + + @Override + public int getMaxEfficiency(ItemStack arg0) { + // TODO Auto-generated method stub + return 10000; + } + + @Override + public int getPollutionPerTick(ItemStack arg0) { + return has_lube ? 50 : 1000; + } + + @Override + public boolean isCorrectMachinePart(ItemStack arg0) { + // TODO Auto-generated method stub + return true; + } + + @Override + public boolean isGivingInformation() { + return true; + } + + @Override + public String[] getInfoData() { + String[] old = super.getInfoData(); + old[2]="Produces "+EMTTextHelper.RED+mEUt+EMTTextHelper.WHITE+"EU/t"; + return old; + } + +/* @Override + public void explodeMultiblock() { + + final World WORLD=this.getBaseMetaTileEntity().getWorld(); + final int xDir = ForgeDirection.getOrientation(this.getBaseMetaTileEntity().getBackFacing()).offsetX * 3; + final int zDir = ForgeDirection.getOrientation(this.getBaseMetaTileEntity().getBackFacing()).offsetZ * 3; + + for (int x = -3; x <= 3; x++) + for (int z = -3; z <= 3; z++) + for (int h = 0; h <= 3; h++) + WORLD.setBlock(xDir+x, this.getBaseMetaTileEntity().getYCoord()+h, zDir+z, ConfigBlocks.blockFluxGas, 8, 3); + super.explodeMultiblock(); + }*/ +} diff --git a/src/main/java/emt/init/EMTTiles.java b/src/main/java/emt/init/EMTTiles.java index 89669c3..343893f 100644 --- a/src/main/java/emt/init/EMTTiles.java +++ b/src/main/java/emt/init/EMTTiles.java @@ -1,6 +1,7 @@ package emt.init; import cpw.mods.fml.common.registry.GameRegistry; +import emt.gthandler.common.implementations.automation.EssentiaFiller; import emt.tile.TileElectricCloud; import emt.tile.TileEntityEtherealMacerator; import emt.tile.TileEntityIndustrialWandRecharge; @@ -48,7 +49,8 @@ public class EMTTiles { //Machinery GameRegistry.registerTileEntity(TileEntityIndustrialWandRecharge.class, "tileentityindustrialwandrecharge"); GameRegistry.registerTileEntity(TileEntityEtherealMacerator.class, "tileentityetherealmacerator"); - + GameRegistry.registerTileEntity(EssentiaFiller.class,"EssentiaFillerTE"); + //Solars GameRegistry.registerTileEntity(TileEntityCompressedSolar.class, "tileentitycompressedsolar"); GameRegistry.registerTileEntity(TileEntityDoubleCompressedSolar.class, "tileentitydoublecompressedsolar"); diff --git a/src/main/java/emt/init/Registry.java b/src/main/java/emt/init/Registry.java index 932fc58..e97c2f6 100644 --- a/src/main/java/emt/init/Registry.java +++ b/src/main/java/emt/init/Registry.java @@ -1,14 +1,19 @@ package emt.init; +import emt.gthandler.common.items.EMT_CasingBlock; +import emt.gthandler.common.loader.EMT_GT_Loader; + public class Registry { - public static void registerPreInit() {} + public static void registerPreInit() { + } public static void registerInit() { EMTBlocks.registerBlocks(); EMTItems.registerItems(); EMTTiles.registerTileEntities(); + new EMT_GT_Loader().run(); EMTRecipes.registerEarlyRecipes(); } diff --git a/src/main/java/emt/item/block/ItemBlockMachines.java b/src/main/java/emt/item/block/ItemBlockMachines.java index f1387fd..080de36 100644 --- a/src/main/java/emt/item/block/ItemBlockMachines.java +++ b/src/main/java/emt/item/block/ItemBlockMachines.java @@ -1,9 +1,12 @@ package emt.item.block; import net.minecraft.block.Block; +import net.minecraft.entity.player.EntityPlayer; import net.minecraft.item.ItemBlock; import net.minecraft.item.ItemStack; +import java.util.List; + public class ItemBlockMachines extends ItemBlock { public ItemBlockMachines(Block id) { @@ -23,7 +26,11 @@ public class ItemBlockMachines extends ItemBlock { name = "etheralprocessor"; break; } - case 2: { + case 2:{ + name = "essentiafiller"; + break; + } + case 3: { name = "raindispeller"; break; } @@ -37,4 +44,16 @@ public class ItemBlockMachines extends ItemBlock { public int getMetadata(int par1) { return par1; } + + @Override + public void addInformation(ItemStack p_77624_1_, EntityPlayer p_77624_2_, List p_77624_3_, boolean p_77624_4_) { + switch (p_77624_1_.getItemDamage()) { + case 3: { + p_77624_3_.add("Connects between Essentia Hatches and the Pipe Network"); + p_77624_3_.add("Looses its Essentia on Restart"); + p_77624_3_.add("Added by bartimaeusnek"); + } + } + + } } diff --git a/src/main/java/emt/tile/generator/TileEntityBaseGenerator.java b/src/main/java/emt/tile/generator/TileEntityBaseGenerator.java index 4fd5d2f..06d1b63 100644 --- a/src/main/java/emt/tile/generator/TileEntityBaseGenerator.java +++ b/src/main/java/emt/tile/generator/TileEntityBaseGenerator.java @@ -273,10 +273,7 @@ public class TileEntityBaseGenerator public boolean doesContainerAccept(Aspect tag) { - if (!tag.equals(this.aspect)) { - return false; - } - return true; + return tag.equals(this.aspect); } public int addToContainer(Aspect tag, int amount) @@ -848,4 +845,13 @@ public class TileEntityBaseGenerator { return false; } + + + public boolean outputsEnergyTo(byte b, boolean b1) { + return true; + } + + public boolean inputEnergyFrom(byte b, boolean b1) { + return false; + } } diff --git a/src/main/java/emt/tile/solar/TileEntitySolarBase.java b/src/main/java/emt/tile/solar/TileEntitySolarBase.java index d03db4b..43d7a6b 100644 --- a/src/main/java/emt/tile/solar/TileEntitySolarBase.java +++ b/src/main/java/emt/tile/solar/TileEntitySolarBase.java @@ -675,4 +675,12 @@ public abstract class TileEntitySolarBase extends TileEntityEMT implements IInve { return false; } + + public boolean outputsEnergyTo(byte b, boolean b1) { + return true; + } + + public boolean inputEnergyFrom(byte b, boolean b1) { + return false; + } } diff --git a/src/main/java/emt/util/EMTConfigHandler.java b/src/main/java/emt/util/EMTConfigHandler.java index 2c0c85d..f7412c4 100644 --- a/src/main/java/emt/util/EMTConfigHandler.java +++ b/src/main/java/emt/util/EMTConfigHandler.java @@ -1,5 +1,7 @@ package emt.util; +import emt.gthandler.common.loader.EMT_GT_Loader; +import gregtech.api.enums.GT_Values; import net.minecraftforge.common.config.Configuration; import java.io.File; @@ -148,7 +150,7 @@ public class EMTConfigHandler { outputCap = config.get(OUTPUTS, "Output Cap", -1).getDouble(outputCap); EssentiaGeneratorStorage=config.get(VALUES,"Essentia Generator Storage",1000000,"This is the number you have to modify if you want to change the size of the "+"internal buffer of the Essentia Generator").getDouble(EssentiaGeneratorStorage); - + EMT_GT_Loader.aIDoffset=config.get(VALUES,"aID for Gregetch Machinery",(13000-GT_Values.VN.length-1),"This Mod will use "+Integer.toString(GT_Values.VN.length+1)+"IDs, do not change if you dont know what you are doing!").getInt(13000-GT_Values.VN.length-1); wandChargerConsumption = config.get(VALUES, "Wand Charging Station Consumption", 50000, "This is the number you have to modify if you want to make the Industrial Wand Charging " + "Station use more or less EU to charge 1 unit of Vis on your wand.").getDouble(wandChargerConsumption); compressedSolarOutput = config.get(VALUES, "Compressed Solar Panel Output", 10, "This is the number you have to modify if you want to make the Compressed Solar Panel yield " + "more or less EU per tick. Really, you shouldn't touch that, " + "since it's pretty balanced as it is.").getDouble(compressedSolarOutput); diff --git a/src/main/resources/assets/emt/lang/en_US.lang b/src/main/resources/assets/emt/lang/en_US.lang index d5b5de8..e4cd6cf 100644 --- a/src/main/resources/assets/emt/lang/en_US.lang +++ b/src/main/resources/assets/emt/lang/en_US.lang @@ -114,6 +114,7 @@ tile.EMT.essentia.aer.name=Aer Generator tile.EMT.essentia.lucrum.name=Lucrum Generator tile.EMT.machine.wandrecharge.name=Industrial Wand Charging Station tile.EMT.machine.etheralprocessor.name=Ethereal Processor +tile.EMT.machine.essentiafiller.name=Essentia Filler tile.EMT.solar.compressed.name=Compressed Solar Panel tile.EMT.solar.doublecompressed.name=Double Compressed Solar Panel tile.EMT.solar.triplecompressed.name=Triple Compressed Solar Panel @@ -136,6 +137,14 @@ tile.EMT.solar2.earth.name=Earth Infused Compressed Solar Panel tile.EMT.solar2.doubleearth.name=Earth Infused Double Compressed Solar Panel tile.EMT.solar2.tripleearth.name=Earth Infused Triple Compressed Solar Panel +#===============Gregtech Compat=============== +EMT_GTBLOCK_CASEING.0.name=Magic Containing Casing +EMT_GTBLOCK_CASEING.1.name=Essentia Diffusion Cell +EMT_GTBLOCK_CASEING.2.name=Iridium Osmiridium Framebox +EMT_GTBLOCK_CASEING.3.name=Indium Tungsten Framebox +EMT_GTBLOCK_CASEING.4.name=Raw Essentia Diffusion Cell +EMT_GTBLOCK_CASEING.5.name=Raw Magic Containing Casing + #=============Thaumonomicon Texts============= emt.rsname.Electric Magic Tools=Electric Magic Tools emt.tag.Electric Magic Tools=Who says magic and technology can't go together? diff --git a/src/main/resources/assets/emt/textures/blocks/machines/GT/inner.png b/src/main/resources/assets/emt/textures/blocks/machines/GT/inner.png new file mode 100644 index 0000000000000000000000000000000000000000..a45e1ab26e0236d073b5aa13d702ba0d9105223a GIT binary patch literal 1490 zcmV;@1ugoCP)N2bZe?^J zG%heMGBNQWX_Wu~1y4ytK~zXfwU*mgR8<(jcfRz-Grjkm|3R)&Zh|)i6{&QzyZ~vK zW^45@E|~#_xiY}qXU+_aT3IUvWEgOWxN3r;tkha%nrUj@GVRIM>UYkUfYu`Cp}l@< z)|qqperNCf?Qb6yS|15jM3U79JE{+~S3y#HCjlKb2ij|r$(;u~b{vdujzQa6f7=?r zZ(YE*&fmJ$*Sf|R+m?uKizjxp$KP$&s^hUL(4yP5SWP@y6So!EK@mMz5hl7JNG7V1 zzOn#>-;6@k6bFBK0EkXdqGR$b^+IHW2JtQJpuL>{qU#{2)`;Gi-=y@=RY`YYGf2?k z^e~KnH4bB6jzPLT4Fg{cs0F^-)Q6)3qdyq!^r_P@a(o2R9cd7yW3dZdt31w?9z}Fs zTm%w&KEVsCl{se~L8qq^L_l=sO1Fw_(xN6UR2k_z(08=C3#Lv_!I_COaN+!gzQY-K z_~;?f0|Ym3-F*D#<4o5e+`e;ruxk(ojtsyjA039S<}Ochi>;su6w#xmSQdf>zULO$ z8uM)`SQ%z;GM{B&^6N<$9~_4tjdsOoM7($Z9`O2%k{mz!gj?RfivjMiwHz;_ugH&`twzodG}cXg~T|J^ZYVmw2K!mf(TNv6p%X&MK%?gBlzBEa|QO? zTnWcQfxUTqp}DvPq-5ckE09^76%^W(wl$$`jmvVMJUI!HeA02A|4)HTvb@~Mk(1Dy z=mnxT6gDD=$F|0qI&!>r*N8ri6dZo@U*u%2{bdOxq2DXt1#%o%7XrCw_9-I^^yOmC zA$mQ6uqgt6-(l1;9l6y&@4-BRnL8ye2Tx4ayn5@BdPA@=Jk&b`QiX2ZyaD%ryAO^V}dB|*=Ba~@>cCr(U&Jj_X5V9uc=7&Ch5`Y+c(J^*BJWZRL_ z$!f35x2mA&{}kjQpa-Tf^UOxkd#E4e0V!VWps9{Dkcga=RZ3_!(e$UsL57YdWlpMT zPq>F1wH7s43hVVA1Wcjl6&RcTa|(#A3j!O0{tZD{s6CM$=s(mCl4`PbWIoRTeU~() zoJdkg^_6{41ikTI2(1r;rNCNOU{OT(zZDPxyC}>jpv2BAkV^hUV5!TuC`XCQUhMRg zw|L6Ej^!@Px#1ZP1_K>z@;j|==^1poj532;bRa{vGi!vFvd!vV){sAK>D02y>eSaefwW^{L9 za%BK;VQFr3E^cLXAT%y8E;2FkAZe8V00Xs2L_t(YOSP6;PgGYJhWncuZjH)GjzyHy z%m_+61b;y<>_xq()~F+cC?E$xq#$ab(Tlcev8NcTwx~fYO>L(WQYeQCF-W{1@$r4P zli8zkH&33xp2J@6?Dc(X?fpT1VG-6xVptc6;;x$7>YCbUV-xOe-jBO$>#(?_6idr1 zu%xUU8}~NjfkQ3GKY0)jv>e7QTeo5E18N&0I4Zu*;0JL_ToPkrV{IK>I59EtRNNEa zib2sT&WRF!M|nl=11hU_;*dC%Xv5#ceK9>fJ#_UN&dkiLt*tp=VPRooW8?abo4CBZ zd_#0z%J`SaL1w_o)&zzEJVh)baKJM$J3HIa+c!5i=YXZ9 zCCbYzAqR|@4q(R8RdGO{aQlP;{uEgO^bBy!xbb6^NCq#-n4h1|3UC!e0g>1q^m6}2 zxcNBW*Y44gq209{xL^5{^18_WaX*Uz5eo1LS<)~pX(pXxkN#3PgGfH&3w$l}th7OZ zx8khNkbX}G(5Y_+Fj4Od@Ny|AD#jq-E5WznKe4*H+W*Bclj|vBIA?ft59BH0Bi5iQ zweq^XQYp4u2m&H|8u7OHRk-2!p4-%Cx_KBHT@prjKgrUMw7JLur(Cs@{cl4Ux1B(HMHE`oY;26cyozd3l)QfV{j{zLlf>?WAfy00000 LNkvXXu0mjf9`yS4 literal 0 HcmV?d00001 diff --git a/src/main/resources/assets/emt/textures/blocks/machines/GT/rawcoreI.png b/src/main/resources/assets/emt/textures/blocks/machines/GT/rawcoreI.png new file mode 100644 index 0000000000000000000000000000000000000000..9a28a0a0fec755d3f0307bbc2890a74cb3152f1e GIT binary patch literal 1128 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 AH~;_u literal 0 HcmV?d00001 diff --git a/src/main/resources/assets/emt/textures/blocks/machines/GT/siderawI.png b/src/main/resources/assets/emt/textures/blocks/machines/GT/siderawI.png new file mode 100644 index 0000000000000000000000000000000000000000..35685ea79b6ddedf59d77f1ca6eeaaa7a29f0641 GIT binary patch literal 1357 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 Hu0mjf(Xs(n literal 0 HcmV?d00001 diff --git a/src/main/resources/assets/emt/textures/blocks/machines/old/rawcoreI.png b/src/main/resources/assets/emt/textures/blocks/machines/old/rawcoreI.png new file mode 100644 index 0000000000000000000000000000000000000000..9240219812a49f40e941897e2948a8ce7e1682d5 GIT binary patch literal 509 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 Q?DYNwHR@PZU4*{yAD?RQ{Qv*} literal 0 HcmV?d00001 diff --git a/src/main/resources/assets/emt/textures/blocks/machines/old/siderawI.png b/src/main/resources/assets/emt/textures/blocks/machines/old/siderawI.png new file mode 100644 index 0000000000000000000000000000000000000000..2ca2078685f87c6ce2e64fdb708b5f68c0f913f9 GIT binary patch literal 620 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 E0PT6WrvLx| literal 0 HcmV?d00001 diff --git a/src/main/resources/assets/emt/textures/blocks/machines/pdn/rawcoreI.pdn b/src/main/resources/assets/emt/textures/blocks/machines/pdn/rawcoreI.pdn new file mode 100644 index 0000000000000000000000000000000000000000..dc13a388ee1ce3cf165be14914efe2ea444ff69a GIT binary patch literal 7290 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 z�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 literal 0 HcmV?d00001 diff --git a/src/main/resources/assets/emt/textures/blocks/machines/pdn/siderawII.pdn b/src/main/resources/assets/emt/textures/blocks/machines/pdn/siderawII.pdn new file mode 100644 index 0000000000000000000000000000000000000000..dff8ecf928a15b23c9b15963dd16b6a0e7f346ce GIT binary patch literal 9331 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 literal 0 HcmV?d00001 diff --git a/src/main/resources/assets/emt/textures/blocks/machines/side.png b/src/main/resources/assets/emt/textures/blocks/machines/side.png index 49d4c9fcc3c152aa867693240c6e7b37a5e4f44f..034d9a43b07060b3ae1f078aee72663591fdb7d7 100644 GIT binary patch delta 1302 zcmV+x1?l?n4yg)|B!2;OQb$4nuFf3k00004XF*Lt006O%3;baP00009a7bBm000id z000id0mpBsWB>pF8FWQhbW?9;ba!ELWdLwtX>N2bZe?^JG%heMGBNQWX_Wu~1er-h zK~zXfwU*sa990;H=O424A5gZG-Pv7sVd;KR*iT@0c6WC1(tiuRZ8R-yfW$P_w%P)L zVjC#ds3>4W#4l7d&=AyELikcdVoK5rlK#&78^&d%y)fa)dvSJl=6&Xz^PY1?i^SrH ze4&KM8HG-xkZJEow|5w&QodL!mAeq>Y&Mn2o{K~gygw{$bw3`%J!Zuynt2t-Q!JQe z!z|Z(JZIe=C4UGz_eo_Lrryhb>yd@fMVK=`KJ`=tZ9tp_!w?F~g`}_N}ekFV^aG*Fu4Z%i)hV0RJ z+#$fbP{7`xAHN6`unqC=0tMsa4mm`z> zk$=E-yS25oxVVVTa&K=BW5ogaM__6Wmpw#S5Lhu7AKa$OYju??3EAr)XwT)cow+Xs z%oV`&VxsIawFU4!M*z_HOQ7IP-C2Z&?6%;I%U2K%0n3pZ4h!47jxKWDP{6I%7P!vT zX?df7L+yb;!NkM_4j*&{4}<>-I9#>>uYWQ*If=2w_D2Ens&(L3M`q42D4^LPsD^V$ zfpzJq0KEqkSPQM(^|D#%x+m}t9+u=M0RzQcEDs8RtbujbKH*UF_;O*0FbCyI*K-6s zeDIDk{qq!HtO@r~E4SbjU=Fa;B{NxGLV>bIXJ%$T5Iz+6FfMY4uq&`^DBv-Lx_`jn z@Lc28>DIk&UDuF3naMZ=fC8RYIMDzuQh;5AJ-|){DB$QH73lRI-8v865^fC*Blt;z z*93U-M*jc;wTO!pAT>_u{*e&`CWfP@Ho56(?xt@GUVj4$$vO{CM8GnY&z2M~T^ELg z8v>6GmH_%r0V)!83Ap>RxG8v7xPKy8yJ;esYD=D&0K2IgDSw0du#H6h!A1nXXAo%P z)W*N9iDYYAqA}ErP+!;47`}fI@}(U+-;g?)4#HrJ#Pu0|jz~@JH zd^syYAjt0-wyAGTB#`A$U}cw2dDTF6gq^(!f?C&$wYA9pLQTz6;{LCItq&XAv;Y7A M07*qoM6N<$f+itTo&W#< literal 1905 zcmbVNc~BE~6b`i!>oq!9#S6DlfeM@KCYxi^BovZRB7`$VEHGq~-H;WM4aw4kV5x;l zwbgn6TCaj)!B!5jRZ$SA;(Dq~7Ur^H#w>yc3`8brm2-NVS~&oT z%Q=gLT1abC5@s^WZ6}i4u{xtW%ZTEfFa;oUNf`qcg2n)sCEMzdy5yY4cBRbRyUpVO zk0ErHob$w~6m2}9r0fJBRIJQ589?#jNBUGfms1Jf73()?L-XQeS0Xm!jTv7jOx zMmuSvNy-X%En)^LmzHxFPoIQfv1zqW4O<<8`4l37fWbVT>cZAI3?)gGqAmfcR&Q3Cyf@P~HW3Gj;(i)YV!<=w&5|@e% zsL>!2h(H807(h&dm_W?PH-Qoeg(MOIBoSiph@EHgl}LCbB#98JQBed8s|Dc_p)g#f zR*PXo2!$h&BV3KuL1R`UF``W}+QVGrxm>BzPGB@;*HKjVNEO7JDVlPaDI1_v0>O(& zD^58buX=CjNx&+?PQFdxk#@=gJWjEce1^Qp#5W2>hycWxC_xlLU=T$h6ch>!Vg$!b zCW!>+4D<2-n>rrj6wg~H|EZgiEv6W~)2Cg)ES~leVP%@f&UA@JeB~b^XaGmRN zb8>2&U&17hr?E73`?NyY6itN!DO@?V`IQKD9{;V3fpvk!=C%Hl=d?$CwF6k8AG0AU z1Uw%Ry`4SKzw|8qYGjdSc5I7$>zzy6s9(0ASu@6XI+3%t`&n!5R+E3HP270%=8`j( z(k51%G!#KDz!=H+T_V0Hmo4P+;u8Dx%%|-=wChQdZn^x zApXra*)m;$nlo9So}NDMfuCP%{n1;08um6c_{0R3wC&p`)N|II&$~ies``YFQj~&3{)N1w=p-l2R`1ewU9+`2mW7{7c zeqWSMJbjM!-tpzK&fkzd4GjsUR{kd4>>e|F-K~#OQ&V-*3Mbao*0L|(ej8Z-O8&~O zq=UxJm}=AOa~7BPZ4+kioB9Ljs5(^>GXQ?q+^JaC(%aj+@fSe$aC&9?@{ar1s*<|H zFTL9qym(bmlK%<+yA~QOImeO*toga<%)Iu96`yvxf_Baii4>i%pYOin==}CI@x%EO z`-*ro8{IdqU0aqjspJO$-)LD1)olNAv;_4W1B9_`(|CvcbZGWO${2Z!%v zSBTjGHwTRi+=_c+C9`HB+>bv$cIA5d;wmRp8 z{f6#t7}xu|phD)VyV2?Hsj8~lY5P7So!i~h6ROzI=(}F6RQyC2`hHl9Rver?;Yjg2 z+k3{x3>>OU$QaGOu|TvrqTg@hgM!aQs|NXTy6CR>qLqJ1XWkgn-;G}8!@9Wk07NDi Q?DYNwHR@PZU4*{yAD?RQ{Qv*} diff --git a/src/main/resources/mcmod.info b/src/main/resources/mcmod.info index c47eada..9073866 100644 --- a/src/main/resources/mcmod.info +++ b/src/main/resources/mcmod.info @@ -7,8 +7,8 @@ "mcversion": "1.7.10", "url": "http://www.minecraftforum.net/topic/2196652-", "updateUrl": "", - "authorList": ["fewizz", "TheSilentium"], - "credits": "Azanor, Tombenpotter, TehNut, the IC2 guys and the forge guys!", + "authorList": ["fewizz", "TheSilentium", "The GT-NH Team", "bartimaeusnek"], + "credits": "Azanor, Tombenpotter, TehNut, the IC2 guys and the forge guys! | LogicFalls for the awesome Big Essentia Gen Textures!", "logoFile": "logo.png", "screenshots": [], "dependencies": ["Thaumcraft 4", "IC2"]