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 0000000..a45e1ab Binary files /dev/null and b/src/main/resources/assets/emt/textures/blocks/machines/GT/inner.png differ diff --git a/src/main/resources/assets/emt/textures/blocks/machines/GT/loader.png b/src/main/resources/assets/emt/textures/blocks/machines/GT/loader.png new file mode 100644 index 0000000..385f4b7 Binary files /dev/null and b/src/main/resources/assets/emt/textures/blocks/machines/GT/loader.png differ 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 0000000..9a28a0a Binary files /dev/null and b/src/main/resources/assets/emt/textures/blocks/machines/GT/rawcoreI.png differ diff --git a/src/main/resources/assets/emt/textures/blocks/machines/GT/rawcoreII.png b/src/main/resources/assets/emt/textures/blocks/machines/GT/rawcoreII.png new file mode 100644 index 0000000..a9f155f Binary files /dev/null and b/src/main/resources/assets/emt/textures/blocks/machines/GT/rawcoreII.png differ 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 0000000..35685ea Binary files /dev/null and b/src/main/resources/assets/emt/textures/blocks/machines/GT/siderawI.png differ diff --git a/src/main/resources/assets/emt/textures/blocks/machines/GT/siderawII.png b/src/main/resources/assets/emt/textures/blocks/machines/GT/siderawII.png new file mode 100644 index 0000000..7b77895 Binary files /dev/null and b/src/main/resources/assets/emt/textures/blocks/machines/GT/siderawII.png differ diff --git a/src/main/resources/assets/emt/textures/blocks/machines/old/inner.png b/src/main/resources/assets/emt/textures/blocks/machines/old/inner.png new file mode 100644 index 0000000..472c60c Binary files /dev/null and b/src/main/resources/assets/emt/textures/blocks/machines/old/inner.png differ 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 0000000..9240219 Binary files /dev/null and b/src/main/resources/assets/emt/textures/blocks/machines/old/rawcoreI.png differ diff --git a/src/main/resources/assets/emt/textures/blocks/machines/old/rawcoreII.png b/src/main/resources/assets/emt/textures/blocks/machines/old/rawcoreII.png new file mode 100644 index 0000000..45754b6 Binary files /dev/null and b/src/main/resources/assets/emt/textures/blocks/machines/old/rawcoreII.png differ diff --git a/src/main/resources/assets/emt/textures/blocks/machines/old/side.png b/src/main/resources/assets/emt/textures/blocks/machines/old/side.png new file mode 100644 index 0000000..49d4c9f Binary files /dev/null and b/src/main/resources/assets/emt/textures/blocks/machines/old/side.png differ 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 0000000..2ca2078 Binary files /dev/null and b/src/main/resources/assets/emt/textures/blocks/machines/old/siderawI.png differ diff --git a/src/main/resources/assets/emt/textures/blocks/machines/old/siderawII.png b/src/main/resources/assets/emt/textures/blocks/machines/old/siderawII.png new file mode 100644 index 0000000..4e1834f Binary files /dev/null and b/src/main/resources/assets/emt/textures/blocks/machines/old/siderawII.png differ diff --git a/src/main/resources/assets/emt/textures/blocks/machines/pdn/inner.pdn b/src/main/resources/assets/emt/textures/blocks/machines/pdn/inner.pdn new file mode 100644 index 0000000..174d066 Binary files /dev/null and b/src/main/resources/assets/emt/textures/blocks/machines/pdn/inner.pdn differ 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 0000000..dc13a38 Binary files /dev/null and b/src/main/resources/assets/emt/textures/blocks/machines/pdn/rawcoreI.pdn differ diff --git a/src/main/resources/assets/emt/textures/blocks/machines/pdn/rawcoreII.pdn b/src/main/resources/assets/emt/textures/blocks/machines/pdn/rawcoreII.pdn new file mode 100644 index 0000000..10a990c Binary files /dev/null and b/src/main/resources/assets/emt/textures/blocks/machines/pdn/rawcoreII.pdn differ diff --git a/src/main/resources/assets/emt/textures/blocks/machines/pdn/side.pdn b/src/main/resources/assets/emt/textures/blocks/machines/pdn/side.pdn new file mode 100644 index 0000000..f2b0fa0 Binary files /dev/null and b/src/main/resources/assets/emt/textures/blocks/machines/pdn/side.pdn differ diff --git a/src/main/resources/assets/emt/textures/blocks/machines/pdn/siderawI.pdn b/src/main/resources/assets/emt/textures/blocks/machines/pdn/siderawI.pdn new file mode 100644 index 0000000..582ec2c Binary files /dev/null and b/src/main/resources/assets/emt/textures/blocks/machines/pdn/siderawI.pdn differ 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 0000000..dff8ecf Binary files /dev/null and b/src/main/resources/assets/emt/textures/blocks/machines/pdn/siderawII.pdn differ 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 49d4c9f..034d9a4 100644 Binary files a/src/main/resources/assets/emt/textures/blocks/machines/side.png and b/src/main/resources/assets/emt/textures/blocks/machines/side.png differ 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"]