diff --git a/src/main/java/mekanism/client/ClientProxy.java b/src/main/java/mekanism/client/ClientProxy.java index c7da63ed9..264a91a32 100644 --- a/src/main/java/mekanism/client/ClientProxy.java +++ b/src/main/java/mekanism/client/ClientProxy.java @@ -158,6 +158,7 @@ import mekanism.common.tile.TileEntityRotaryCondensentrator; import mekanism.common.tile.TileEntitySeismicVibrator; import mekanism.common.tile.TileEntitySolarEvaporationController; import mekanism.common.tile.TileEntitySolarNeutronActivator; +import mekanism.common.tile.TileEntityStructuralGlass; import mekanism.common.tile.TileEntityTeleporter; import net.minecraft.client.Minecraft; import net.minecraft.client.gui.GuiScreen; @@ -324,6 +325,7 @@ public class ClientProxy extends CommonProxy GameRegistry.registerTileEntity(TileEntityInductionCell.class, "InductionCell"); GameRegistry.registerTileEntity(TileEntityInductionProvider.class, "InductionProvider"); GameRegistry.registerTileEntity(TileEntityOredictionificator.class, "Oredictionificator"); + GameRegistry.registerTileEntity(TileEntityStructuralGlass.class, "StructuralGlass"); } @Override diff --git a/src/main/java/mekanism/client/render/block/CTMRenderingHandler.java b/src/main/java/mekanism/client/render/block/CTMRenderingHandler.java index 8746bdd91..b41e830b5 100644 --- a/src/main/java/mekanism/client/render/block/CTMRenderingHandler.java +++ b/src/main/java/mekanism/client/render/block/CTMRenderingHandler.java @@ -32,6 +32,11 @@ public class CTMRenderingHandler implements ISimpleBlockRenderingHandler public boolean renderWorldBlock(IBlockAccess world, int x, int y, int z, Block block, int modelId, RenderBlocks rendererOld) { int meta = world.getBlockMetadata(x, y, z); + + if(block instanceof IBlockCTM && !((IBlockCTM)block).shouldRenderBlock(world, x, y, z, meta)) + { + return false; + } CTMData blockCTM = ((IBlockCTM)block).getCTMData(world, x, y, z, meta); @@ -57,32 +62,27 @@ public class CTMRenderingHandler implements ISimpleBlockRenderingHandler if(MachineType.get(block, meta) != null) { - if(!MachineType.get(block, meta).hasModel) + TileEntity tile = world.getTileEntity(x, y, z); + + int prevRotateTop = rendererOld.uvRotateTop; + int prevRotateBottom = rendererOld.uvRotateBottom; + + if(tile instanceof TileEntityBasicBlock) { - TileEntity tile = world.getTileEntity(x, y, z); - - int prevRotateTop = rendererOld.uvRotateTop; - int prevRotateBottom = rendererOld.uvRotateBottom; - - if(tile instanceof TileEntityBasicBlock) + if(((TileEntityBasicBlock)tile).facing >= 2) { - if(((TileEntityBasicBlock)tile).facing >= 2) - { - rendererOld.uvRotateTop = MekanismRenderer.directionMap[((TileEntityBasicBlock)tile).facing-2]; - rendererOld.uvRotateBottom = MekanismRenderer.directionMap[((TileEntityBasicBlock)tile).facing-2]; - } + rendererOld.uvRotateTop = MekanismRenderer.directionMap[((TileEntityBasicBlock)tile).facing-2]; + rendererOld.uvRotateBottom = MekanismRenderer.directionMap[((TileEntityBasicBlock)tile).facing-2]; } - - rendererOld.renderStandardBlock(block, x, y, z); - rendererOld.setRenderBoundsFromBlock(block); - - rendererOld.uvRotateTop = prevRotateTop; - rendererOld.uvRotateBottom = prevRotateBottom; - - return true; } - return false; + rendererOld.renderStandardBlock(block, x, y, z); + rendererOld.setRenderBoundsFromBlock(block); + + rendererOld.uvRotateTop = prevRotateTop; + rendererOld.uvRotateBottom = prevRotateBottom; + + return true; } return rendererOld.renderStandardBlock(block, x, y, z); diff --git a/src/main/java/mekanism/client/render/block/RenderBlocksCTM.java b/src/main/java/mekanism/client/render/block/RenderBlocksCTM.java index 6a319c14d..0676e396e 100644 --- a/src/main/java/mekanism/client/render/block/RenderBlocksCTM.java +++ b/src/main/java/mekanism/client/render/block/RenderBlocksCTM.java @@ -15,7 +15,6 @@ import net.minecraft.util.IIcon; */ public class RenderBlocksCTM extends RenderBlocks { - RenderBlocksCTM() { super(); diff --git a/src/main/java/mekanism/common/CommonProxy.java b/src/main/java/mekanism/common/CommonProxy.java index 3cc343f5b..9e7110ad1 100644 --- a/src/main/java/mekanism/common/CommonProxy.java +++ b/src/main/java/mekanism/common/CommonProxy.java @@ -104,6 +104,7 @@ import mekanism.common.tile.TileEntityRotaryCondensentrator; import mekanism.common.tile.TileEntitySeismicVibrator; import mekanism.common.tile.TileEntitySolarEvaporationController; import mekanism.common.tile.TileEntitySolarNeutronActivator; +import mekanism.common.tile.TileEntityStructuralGlass; import mekanism.common.tile.TileEntityTeleporter; import net.minecraft.entity.player.EntityPlayer; import net.minecraft.entity.player.EntityPlayerMP; @@ -192,6 +193,7 @@ public class CommonProxy GameRegistry.registerTileEntity(TileEntityInductionCell.class, "InductionCell"); GameRegistry.registerTileEntity(TileEntityInductionProvider.class, "InductionProvider"); GameRegistry.registerTileEntity(TileEntityOredictionificator.class, "Oredictionificator"); + GameRegistry.registerTileEntity(TileEntityStructuralGlass.class, "StructuralGlass"); } public void handleTeleporterUpdate(PortableTeleporterMessage message) {} diff --git a/src/main/java/mekanism/common/Mekanism.java b/src/main/java/mekanism/common/Mekanism.java index fe3e028f7..550d2a51d 100644 --- a/src/main/java/mekanism/common/Mekanism.java +++ b/src/main/java/mekanism/common/Mekanism.java @@ -47,7 +47,6 @@ import mekanism.common.content.matrix.SynchronizedMatrixData; import mekanism.common.content.tank.SynchronizedTankData; import mekanism.common.content.transporter.PathfinderCache; import mekanism.common.content.transporter.TransporterManager; -import mekanism.common.content.turbine.SynchronizedTurbineData; import mekanism.common.entity.EntityBabySkeleton; import mekanism.common.entity.EntityBalloon; import mekanism.common.entity.EntityFlame; @@ -170,7 +169,6 @@ public class Mekanism /** MultiblockManagers for various structrures */ public static MultiblockManager tankManager = new MultiblockManager("dynamicTank"); public static MultiblockManager matrixManager = new MultiblockManager("inductionMatrix"); - public static MultiblockManager turbineManager = new MultiblockManager("industrialTurbine"); public static MultiblockManager boilerManager = new BoilerManager("thermoelectricBoiler"); /** FrequencyManagers for various networks */ diff --git a/src/main/java/mekanism/common/base/IBlockCTM.java b/src/main/java/mekanism/common/base/IBlockCTM.java index 36a54a45c..c00d69f55 100644 --- a/src/main/java/mekanism/common/base/IBlockCTM.java +++ b/src/main/java/mekanism/common/base/IBlockCTM.java @@ -1,10 +1,11 @@ package mekanism.common.base; import mekanism.common.CTMData; - import net.minecraft.world.IBlockAccess; public interface IBlockCTM { public CTMData getCTMData(IBlockAccess world, int x, int y, int z, int meta); + + public boolean shouldRenderBlock(IBlockAccess world, int x, int y, int z, int meta); } diff --git a/src/main/java/mekanism/common/block/BlockBasic.java b/src/main/java/mekanism/common/block/BlockBasic.java index 720525a1a..cd76f26ab 100644 --- a/src/main/java/mekanism/common/block/BlockBasic.java +++ b/src/main/java/mekanism/common/block/BlockBasic.java @@ -1,11 +1,10 @@ package mekanism.common.block; -import buildcraft.api.tools.IToolWrench; -import net.minecraftforge.fml.common.FMLCommonHandler; -import net.minecraftforge.fml.relauncher.Side; -import net.minecraftforge.fml.relauncher.SideOnly; +import java.util.Arrays; +import java.util.List; +import java.util.Random; + import mekanism.api.Coord4D; -import mekanism.api.Range4D; import mekanism.api.energy.IEnergizedItem; import mekanism.api.energy.IStrictEnergyStorage; import mekanism.client.render.MekanismRenderer; @@ -22,8 +21,20 @@ import mekanism.common.base.IBoundingBlock; import mekanism.common.content.tank.TankUpdateProtocol; import mekanism.common.inventory.InventoryBin; import mekanism.common.item.ItemBlockBasic; -import mekanism.common.network.PacketTileEntity.TileEntityMessage; -import mekanism.common.tile.*; +import mekanism.common.multiblock.IMultiblock; +import mekanism.common.multiblock.IStructuralMultiblock; +import mekanism.common.tile.TileEntityBasicBlock; +import mekanism.common.tile.TileEntityBin; +import mekanism.common.tile.TileEntityDynamicTank; +import mekanism.common.tile.TileEntityDynamicValve; +import mekanism.common.tile.TileEntityInductionCasing; +import mekanism.common.tile.TileEntityInductionCell; +import mekanism.common.tile.TileEntityInductionPort; +import mekanism.common.tile.TileEntityInductionProvider; +import mekanism.common.tile.TileEntitySolarEvaporationBlock; +import mekanism.common.tile.TileEntitySolarEvaporationController; +import mekanism.common.tile.TileEntitySolarEvaporationValve; +import mekanism.common.tile.TileEntityStructuralGlass; import mekanism.common.util.MekanismUtils; import net.minecraft.block.Block; import net.minecraft.block.material.Material; @@ -46,11 +57,10 @@ import net.minecraft.world.World; import net.minecraft.util.EnumFacing; import net.minecraftforge.fluids.FluidContainerRegistry; import net.minecraftforge.fluids.FluidStack; - -import java.util.ArrayList; -import java.util.Arrays; -import java.util.List; -import java.util.Random; +import buildcraft.api.tools.IToolWrench; +import net.minecraftforge.fml.common.FMLCommonHandler; +import net.minecraftforge.fml.relauncher.Side; +import net.minecraftforge.fml.relauncher.SideOnly; /** * Block class for handling multiple metal block IDs. @@ -64,7 +74,7 @@ import java.util.Random; * 0:7: Teleporter Frame * 0:8: Steel Casing * 0:9: Dynamic Tank - * 0:10: Dynamic Glass + * 0:10: Structural Glass * 0:11: Dynamic Valve * 0:12: Copper Block * 0:13: Tin Block @@ -119,15 +129,20 @@ public class BlockBasic extends Block implements IBlockCTM, ICustomBlockIcon { TileEntity tileEntity = world.getTileEntity(x, y, z); - if(block == this && tileEntity instanceof TileEntityMultiblock) + if(block == this && tileEntity instanceof IMultiblock) { - ((TileEntityMultiblock)tileEntity).update(); + ((IMultiblock)tileEntity).update(); } if(tileEntity instanceof TileEntityBasicBlock) { ((TileEntityBasicBlock)tileEntity).onNeighborChange(block); } + + if(tileEntity instanceof IStructuralMultiblock) + { + ((IStructuralMultiblock)tileEntity).update(); + } } } @@ -526,24 +541,13 @@ public class BlockBasic extends Block implements IBlockCTM, ICustomBlockIcon return true; } - else if(metadata == 9 || metadata == 10 || metadata == 11) + else if(metadata == 9 || metadata == 11) { - if(!entityplayer.isSneaking() && ((TileEntityDynamicTank)world.getTileEntity(x, y, z)).structure != null) - { - TileEntityDynamicTank tileEntity = (TileEntityDynamicTank)world.getTileEntity(x, y, z); - - if(!manageInventory(entityplayer, tileEntity)) - { - Mekanism.packetHandler.sendToReceivers(new TileEntityMessage(Coord4D.get(tileEntity), tileEntity.getNetworkedData(new ArrayList())), new Range4D(Coord4D.get(tileEntity))); - entityplayer.openGui(Mekanism.instance, 18, world, x, y, z); - } - else { - entityplayer.inventory.markDirty(); - tileEntity.sendPacketToRenderer(); - } - - return true; - } + return ((IMultiblock)world.getTileEntity(x, y, z)).onActivate(entityplayer); + } + else if(metadata == 10) + { + return ((IStructuralMultiblock)world.getTileEntity(x, y, z)).onActivate(entityplayer); } } else if(blockType == BasicBlock.BASIC_BLOCK_2) @@ -555,15 +559,7 @@ public class BlockBasic extends Block implements IBlockCTM, ICustomBlockIcon if(metadata == 1 || metadata == 2) { - if(!entityplayer.isSneaking() && ((TileEntityInductionCasing)world.getTileEntity(x, y, z)).structure != null) - { - TileEntityInductionCasing tileEntity = (TileEntityInductionCasing)world.getTileEntity(x, y, z); - - Mekanism.packetHandler.sendToReceivers(new TileEntityMessage(Coord4D.get(tileEntity), tileEntity.getNetworkedData(new ArrayList())), new Range4D(Coord4D.get(tileEntity))); - entityplayer.openGui(Mekanism.instance, 49, world, x, y, z); - - return true; - } + return ((IMultiblock)world.getTileEntity(x, y, z)).onActivate(entityplayer); } } @@ -576,7 +572,7 @@ public class BlockBasic extends Block implements IBlockCTM, ICustomBlockIcon return !(blockType == BasicBlock.BASIC_BLOCK_1 && world.getBlockMetadata(x, y, z) == 10); } - private boolean manageInventory(EntityPlayer player, TileEntityDynamicTank tileEntity) + public static boolean manageInventory(EntityPlayer player, TileEntityDynamicTank tileEntity) { ItemStack itemStack = player.getCurrentEquippedItem(); @@ -808,7 +804,7 @@ public class BlockBasic extends Block implements IBlockCTM, ICustomBlockIcon case 9: return new TileEntityDynamicTank(); case 10: - return new TileEntityDynamicTank(); + return new TileEntityStructuralGlass(); case 11: return new TileEntityDynamicValve(); case 14: @@ -889,9 +885,14 @@ public class BlockBasic extends Block implements IBlockCTM, ICustomBlockIcon { TileEntity tileEntity = world.getTileEntity(x, y, z); - if(tileEntity instanceof TileEntityMultiblock) + if(tileEntity instanceof IMultiblock) { - ((TileEntityMultiblock)tileEntity).update(); + ((IMultiblock)tileEntity).update(); + } + + if(tileEntity instanceof IStructuralMultiblock) + { + ((IStructuralMultiblock)tileEntity).update(); } } } @@ -1067,6 +1068,12 @@ public class BlockBasic extends Block implements IBlockCTM, ICustomBlockIcon return ctms[meta][0]; } + + @Override + public boolean shouldRenderBlock(IBlockAccess world, int x, int y, int z, int meta) + { + return true; + } public static enum BasicBlock { diff --git a/src/main/java/mekanism/common/block/BlockMachine.java b/src/main/java/mekanism/common/block/BlockMachine.java index 119be1b17..1b447b13f 100644 --- a/src/main/java/mekanism/common/block/BlockMachine.java +++ b/src/main/java/mekanism/common/block/BlockMachine.java @@ -1,8 +1,12 @@ package mekanism.common.block; -import buildcraft.api.tools.IToolWrench; -import net.minecraftforge.fml.relauncher.Side; -import net.minecraftforge.fml.relauncher.SideOnly; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Collection; +import java.util.HashSet; +import java.util.List; +import java.util.Random; + import mekanism.api.Coord4D; import mekanism.api.EnumColor; import mekanism.api.MekanismConfig.client; @@ -19,15 +23,63 @@ import mekanism.common.ItemAttacher; import mekanism.common.Mekanism; import mekanism.common.MekanismBlocks; import mekanism.common.Tier.BaseTier; -import mekanism.common.base.*; +import mekanism.common.base.IActiveState; +import mekanism.common.base.IBlockCTM; +import mekanism.common.base.IBoundingBlock; +import mekanism.common.base.IElectricChest; +import mekanism.common.base.IFactory; import mekanism.common.base.IFactory.RecipeType; +import mekanism.common.base.IRedstoneControl; +import mekanism.common.base.ISideConfiguration; +import mekanism.common.base.ISpecialBounds; +import mekanism.common.base.ISustainedData; +import mekanism.common.base.ISustainedInventory; +import mekanism.common.base.ISustainedTank; +import mekanism.common.base.IUpgradeTile; import mekanism.common.item.ItemBlockMachine; import mekanism.common.network.PacketElectricChest.ElectricChestMessage; import mekanism.common.network.PacketElectricChest.ElectricChestPacketType; import mekanism.common.network.PacketLogisticalSorterGui.LogisticalSorterGuiMessage; import mekanism.common.network.PacketLogisticalSorterGui.SorterGuiPacket; import mekanism.common.recipe.ShapedMekanismRecipe; -import mekanism.common.tile.*; +import mekanism.common.tile.TileEntityAdvancedFactory; +import mekanism.common.tile.TileEntityAmbientAccumulator; +import mekanism.common.tile.TileEntityBasicBlock; +import mekanism.common.tile.TileEntityChargepad; +import mekanism.common.tile.TileEntityChemicalCrystallizer; +import mekanism.common.tile.TileEntityChemicalDissolutionChamber; +import mekanism.common.tile.TileEntityChemicalInfuser; +import mekanism.common.tile.TileEntityChemicalInjectionChamber; +import mekanism.common.tile.TileEntityChemicalOxidizer; +import mekanism.common.tile.TileEntityChemicalWasher; +import mekanism.common.tile.TileEntityCombiner; +import mekanism.common.tile.TileEntityContainerBlock; +import mekanism.common.tile.TileEntityCrusher; +import mekanism.common.tile.TileEntityDigitalMiner; +import mekanism.common.tile.TileEntityElectricChest; +import mekanism.common.tile.TileEntityElectricPump; +import mekanism.common.tile.TileEntityElectrolyticSeparator; +import mekanism.common.tile.TileEntityEliteFactory; +import mekanism.common.tile.TileEntityEnergizedSmelter; +import mekanism.common.tile.TileEntityEnrichmentChamber; +import mekanism.common.tile.TileEntityEntangledBlock; +import mekanism.common.tile.TileEntityFactory; +import mekanism.common.tile.TileEntityFluidicPlenisher; +import mekanism.common.tile.TileEntityLaser; +import mekanism.common.tile.TileEntityLaserAmplifier; +import mekanism.common.tile.TileEntityLaserTractorBeam; +import mekanism.common.tile.TileEntityLogisticalSorter; +import mekanism.common.tile.TileEntityMetallurgicInfuser; +import mekanism.common.tile.TileEntityOredictionificator; +import mekanism.common.tile.TileEntityOsmiumCompressor; +import mekanism.common.tile.TileEntityPRC; +import mekanism.common.tile.TileEntityPortableTank; +import mekanism.common.tile.TileEntityPrecisionSawmill; +import mekanism.common.tile.TileEntityPurificationChamber; +import mekanism.common.tile.TileEntityRotaryCondensentrator; +import mekanism.common.tile.TileEntitySeismicVibrator; +import mekanism.common.tile.TileEntitySolarNeutronActivator; +import mekanism.common.tile.TileEntityTeleporter; import mekanism.common.util.LangUtils; import mekanism.common.util.MekanismUtils; import net.minecraft.block.Block; @@ -45,7 +97,11 @@ import net.minecraft.item.Item; import net.minecraft.item.ItemStack; import net.minecraft.nbt.NBTTagCompound; import net.minecraft.tileentity.TileEntity; -import net.minecraft.util.*; +import net.minecraft.util.AxisAlignedBB; +import net.minecraft.util.ChatComponentText; +import net.minecraft.util.IIcon; +import net.minecraft.util.MathHelper; +import net.minecraft.util.MovingObjectPosition; import net.minecraft.world.IBlockAccess; import net.minecraft.world.World; import net.minecraft.util.EnumFacing; @@ -53,8 +109,9 @@ import net.minecraftforge.fluids.Fluid; import net.minecraftforge.fluids.FluidContainerRegistry; import net.minecraftforge.fluids.FluidRegistry; import net.minecraftforge.fluids.FluidStack; - -import java.util.*; +import buildcraft.api.tools.IToolWrench; +import net.minecraftforge.fml.relauncher.Side; +import net.minecraftforge.fml.relauncher.SideOnly; /** * Block class for handling multiple machine block IDs. @@ -1355,4 +1412,10 @@ public class BlockMachine extends BlockContainer implements ISpecialBounds, IBlo return ctms[meta][0]; } + + @Override + public boolean shouldRenderBlock(IBlockAccess world, int x, int y, int z, int meta) + { + return !MachineType.get(this, meta).hasModel; + } } diff --git a/src/main/java/mekanism/common/content/tank/DynamicFluidTank.java b/src/main/java/mekanism/common/content/tank/DynamicFluidTank.java index 173739a37..994d2ed5f 100644 --- a/src/main/java/mekanism/common/content/tank/DynamicFluidTank.java +++ b/src/main/java/mekanism/common/content/tank/DynamicFluidTank.java @@ -154,7 +154,7 @@ public class DynamicFluidTank implements IFluidTank dynamicTank.structure.fluidStored.amount -= used; } - FluidStack drained = new FluidStack(dynamicTank.structure.fluidStored.getFluidID(), used); + FluidStack drained = new FluidStack(dynamicTank.structure.fluidStored.getFluid(), used); if(dynamicTank.structure.fluidStored.amount <= 0) { diff --git a/src/main/java/mekanism/common/content/turbine/SynchronizedTurbineData.java b/src/main/java/mekanism/common/content/turbine/SynchronizedTurbineData.java deleted file mode 100644 index a7291b75a..000000000 --- a/src/main/java/mekanism/common/content/turbine/SynchronizedTurbineData.java +++ /dev/null @@ -1,8 +0,0 @@ -package mekanism.common.content.turbine; - -import mekanism.common.multiblock.SynchronizedData; - -public class SynchronizedTurbineData extends SynchronizedData -{ - -} diff --git a/src/main/java/mekanism/common/content/turbine/TurbineCache.java b/src/main/java/mekanism/common/content/turbine/TurbineCache.java deleted file mode 100644 index f2ac0a065..000000000 --- a/src/main/java/mekanism/common/content/turbine/TurbineCache.java +++ /dev/null @@ -1,32 +0,0 @@ -package mekanism.common.content.turbine; - -import mekanism.common.multiblock.MultiblockCache; - -import net.minecraft.nbt.NBTTagCompound; - -public class TurbineCache extends MultiblockCache -{ - @Override - public void apply(SynchronizedTurbineData data) - { - - } - - @Override - public void sync(SynchronizedTurbineData data) - { - - } - - @Override - public void load(NBTTagCompound nbtTags) - { - - } - - @Override - public void save(NBTTagCompound nbtTags) - { - - } -} diff --git a/src/main/java/mekanism/common/content/turbine/TurbineUpdateProtocol.java b/src/main/java/mekanism/common/content/turbine/TurbineUpdateProtocol.java deleted file mode 100644 index 81d437e28..000000000 --- a/src/main/java/mekanism/common/content/turbine/TurbineUpdateProtocol.java +++ /dev/null @@ -1,6 +0,0 @@ -package mekanism.common.content.turbine; - -public class TurbineUpdateProtocol -{ - -} diff --git a/src/main/java/mekanism/common/item/ItemBlockBasic.java b/src/main/java/mekanism/common/item/ItemBlockBasic.java index 745c1cac8..d7ad13051 100644 --- a/src/main/java/mekanism/common/item/ItemBlockBasic.java +++ b/src/main/java/mekanism/common/item/ItemBlockBasic.java @@ -1,7 +1,8 @@ package mekanism.common.item; -import net.minecraftforge.fml.relauncher.Side; -import net.minecraftforge.fml.relauncher.SideOnly; +import java.util.ArrayList; +import java.util.List; + import mekanism.api.Coord4D; import mekanism.api.EnumColor; import mekanism.api.Range4D; @@ -28,9 +29,8 @@ import net.minecraft.nbt.NBTTagCompound; import net.minecraft.tileentity.TileEntity; import net.minecraft.util.IIcon; import net.minecraft.world.World; - -import java.util.ArrayList; -import java.util.List; +import net.minecraftforge.fml.relauncher.Side; +import net.minecraftforge.fml.relauncher.SideOnly; /** * Item class for handling multiple metal block IDs. @@ -44,7 +44,7 @@ import java.util.List; * 0:7: Teleporter Frame * 0:8: Steel Casing * 0:9: Dynamic Tank - * 0:10: Dynamic Glass + * 0:10: Structural Glass * 0:11: Dynamic Valve * 0:12: Copper Block * 0:13: Tin Block @@ -306,7 +306,7 @@ public class ItemBlockBasic extends ItemBlock implements IEnergizedItem name = "DynamicTank"; break; case 10: - name = "DynamicGlass"; + name = "StructuralGlass"; break; case 11: name = "DynamicValve"; diff --git a/src/main/java/mekanism/common/multiblock/IMultiblock.java b/src/main/java/mekanism/common/multiblock/IMultiblock.java index dc2ae616b..97ec03128 100644 --- a/src/main/java/mekanism/common/multiblock/IMultiblock.java +++ b/src/main/java/mekanism/common/multiblock/IMultiblock.java @@ -1,6 +1,12 @@ package mekanism.common.multiblock; +import net.minecraft.entity.player.EntityPlayer; + public interface IMultiblock> { public T getSynchronizedData(); + + public boolean onActivate(EntityPlayer player); + + public void update(); } diff --git a/src/main/java/mekanism/common/multiblock/IStructuralMultiblock.java b/src/main/java/mekanism/common/multiblock/IStructuralMultiblock.java new file mode 100644 index 000000000..eda5c272a --- /dev/null +++ b/src/main/java/mekanism/common/multiblock/IStructuralMultiblock.java @@ -0,0 +1,17 @@ +package mekanism.common.multiblock; + +import mekanism.api.Coord4D; +import net.minecraft.block.Block; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.tileentity.TileEntity; + +public interface IStructuralMultiblock +{ + public boolean onActivate(EntityPlayer player); + + public boolean canInterface(TileEntity controller); + + public void setController(Coord4D coord); + + public void update(); +} diff --git a/src/main/java/mekanism/common/multiblock/UpdateProtocol.java b/src/main/java/mekanism/common/multiblock/UpdateProtocol.java index 17b4e3265..77b1eff4f 100644 --- a/src/main/java/mekanism/common/multiblock/UpdateProtocol.java +++ b/src/main/java/mekanism/common/multiblock/UpdateProtocol.java @@ -6,6 +6,7 @@ import java.util.List; import java.util.Set; import mekanism.api.Coord4D; +import mekanism.common.Mekanism; import mekanism.common.tile.TileEntityMultiblock; import net.minecraft.item.ItemStack; import net.minecraft.tileentity.TileEntity; @@ -15,7 +16,7 @@ import net.minecraft.util.EnumFacing; public abstract class UpdateProtocol> { /** The multiblock nodes that have already been iterated over. */ - public Set> iteratedNodes = new HashSet>(); + public Set iteratedNodes = new HashSet(); public Set innerNodes = new HashSet(); @@ -34,7 +35,7 @@ public abstract class UpdateProtocol> * Recursively loops through each node connected to the given TileEntity. * @param tile - the TileEntity to loop over */ - public void loopThrough(TileEntityMultiblock tile) + public void loopThrough(TileEntity tile) { World worldObj = tile.getWorldObj(); @@ -157,7 +158,10 @@ public abstract class UpdateProtocol> break; } else { - innerNodes.add(new Coord4D(origX+x, origY+y, origZ+z, pointer.getWorldObj().provider.getDimensionId())); + if(!isAir(origX+x, origY+y, origZ+z)) + { + innerNodes.add(new Coord4D(origX+x, origY+y, origZ+z, pointer.getWorldObj().provider.getDimensionId())); + } } volume++; @@ -199,7 +203,7 @@ public abstract class UpdateProtocol> if(structure.locations.contains(Coord4D.get(pointer)) && isCorrectCorner(Coord4D.get(tile), origX+xmin, origY+ymin, origZ+zmin)) { - if(isInteriorValid(structure)) + if(canForm(structure)) { structureFound = structure; return; @@ -214,19 +218,20 @@ public abstract class UpdateProtocol> for(EnumFacing side : EnumFacing.VALUES) { - TileEntity tileEntity = Coord4D.get(tile).offset(side).getTileEntity(tile.getWorldObj()); + Coord4D coord = Coord4D.get(tile).offset(side); + TileEntity tileEntity = coord.getTileEntity(tile.getWorldObj()); - if(MultiblockManager.areEqual(tileEntity, pointer)) + if(isViableNode(coord.xCoord, coord.yCoord, coord.zCoord)) { if(!iteratedNodes.contains(tileEntity)) { - loopThrough((TileEntityMultiblock)tileEntity); + loopThrough(tileEntity); } } } } - public boolean isInteriorValid(T structure) + protected boolean canForm(T structure) { return true; } @@ -289,6 +294,14 @@ public abstract class UpdateProtocol> { TileEntity tile = pointer.getWorldObj().getTileEntity(x, y, z); + if(tile instanceof IStructuralMultiblock) + { + if(((IStructuralMultiblock)tile).canInterface(pointer)) + { + return true; + } + } + if(MultiblockManager.areEqual(tile, pointer)) { return true; @@ -381,6 +394,8 @@ public abstract class UpdateProtocol> protected void onStructureCreated(T structure, int origX, int origY, int origZ, int xmin, int xmax, int ymin, int ymax, int zmin, int zmax) {} public void onStructureDestroyed(T structure) {} + + public void killInnerNode(Coord4D coord) {} /** * Runs the protocol and updates all nodes that make a part of the multiblock. @@ -391,13 +406,25 @@ public abstract class UpdateProtocol> if(structureFound != null) { - for(TileEntityMultiblock tileEntity : iteratedNodes) + for(TileEntity tileEntity : iteratedNodes) { if(!structureFound.locations.contains(Coord4D.get(tileEntity))) { for(TileEntity tile : iteratedNodes) { - ((TileEntityMultiblock)tile).structure = null; + if(tile instanceof TileEntityMultiblock) + { + ((TileEntityMultiblock)tile).structure = null; + } + else if(tile instanceof IStructuralMultiblock) + { + ((IStructuralMultiblock)tile).setController(null); + } + } + + for(Coord4D coord : innerNodes) + { + killInnerNode(coord); } return; @@ -409,11 +436,11 @@ public abstract class UpdateProtocol> for(Coord4D obj : structureFound.locations) { - TileEntityMultiblock tileEntity = (TileEntityMultiblock)obj.getTileEntity(pointer.getWorldObj()); + TileEntity tileEntity = obj.getTileEntity(pointer.getWorldObj()); - if(tileEntity.cachedID != null) + if(tileEntity instanceof TileEntityMultiblock && ((TileEntityMultiblock)tileEntity).cachedID != null) { - idsFound.add(tileEntity.cachedID); + idsFound.add(((TileEntityMultiblock)tileEntity).cachedID); } } @@ -451,24 +478,60 @@ public abstract class UpdateProtocol> onFormed(); structureFound.inventoryID = idToUse; + + List structures = new ArrayList(); + Coord4D toUse = null; for(Coord4D obj : structureFound.locations) { - TileEntityMultiblock tileEntity = (TileEntityMultiblock)obj.getTileEntity(pointer.getWorldObj()); + TileEntity tileEntity = obj.getTileEntity(pointer.getWorldObj()); - tileEntity.structure = (T)structureFound; + if(tileEntity instanceof TileEntityMultiblock) + { + ((TileEntityMultiblock)tileEntity).structure = structureFound; + + if(toUse == null) + { + toUse = obj.clone(); + } + } + else if(tileEntity instanceof IStructuralMultiblock) + { + structures.add((IStructuralMultiblock)tileEntity); + } + } + + //Remove all structural multiblocks from locations, set controllers + for(IStructuralMultiblock node : structures) + { + node.setController(toUse); + structureFound.locations.remove(Coord4D.get((TileEntity)node)); } } else { - for(TileEntityMultiblock tileEntity : iteratedNodes) + for(TileEntity tile : iteratedNodes) { - if(tileEntity.structure != null && !tileEntity.structure.destroyed) + if(tile instanceof TileEntityMultiblock) { - onStructureDestroyed(tileEntity.structure); - tileEntity.structure.destroyed = true; + TileEntityMultiblock tileEntity = (TileEntityMultiblock)tile; + + if(tileEntity.structure != null && !tileEntity.structure.destroyed) + { + onStructureDestroyed(tileEntity.structure); + tileEntity.structure.destroyed = true; + } + + tileEntity.structure = null; } - - tileEntity.structure = null; + else if(tile instanceof IStructuralMultiblock) + { + ((IStructuralMultiblock)tile).setController(null); + } + } + + for(Coord4D coord : innerNodes) + { + killInnerNode(coord); } } } diff --git a/src/main/java/mekanism/common/tile/TileEntityDynamicTank.java b/src/main/java/mekanism/common/tile/TileEntityDynamicTank.java index b4c5ce293..5123fdc9f 100644 --- a/src/main/java/mekanism/common/tile/TileEntityDynamicTank.java +++ b/src/main/java/mekanism/common/tile/TileEntityDynamicTank.java @@ -10,6 +10,7 @@ import mekanism.api.Coord4D; import mekanism.api.Range4D; import mekanism.common.Mekanism; import mekanism.common.base.IFluidContainerManager; +import mekanism.common.block.BlockBasic; import mekanism.common.content.tank.SynchronizedTankData; import mekanism.common.content.tank.SynchronizedTankData.ValveData; import mekanism.common.content.tank.TankCache; @@ -18,9 +19,11 @@ import mekanism.common.multiblock.MultiblockManager; import mekanism.common.network.PacketTileEntity.TileEntityMessage; import mekanism.common.util.FluidContainerUtils; import mekanism.common.util.FluidContainerUtils.ContainerEditMode; +import net.minecraft.entity.player.EntityPlayer; import net.minecraft.item.ItemStack; import net.minecraft.util.EnumFacing; import net.minecraftforge.fluids.FluidContainerRegistry; +import net.minecraftforge.fluids.FluidRegistry; import net.minecraftforge.fluids.FluidStack; import net.minecraftforge.fluids.IFluidContainerItem; @@ -280,6 +283,27 @@ public class TileEntityDynamicTank extends TileEntityMultiblock implements IStrictEnergyStorage, IComputerIntegration { public int clientCells; @@ -52,6 +57,20 @@ public class TileEntityInductionCasing extends TileEntityMultiblock> extend } } + @Override public void update() { if(!worldObj.isRemote && (structure == null || !getSynchronizedData().didTick)) @@ -273,6 +275,12 @@ public abstract class TileEntityMultiblock> extend } } + @Override + public boolean onActivate(EntityPlayer player) + { + return false; + } + @Override @SideOnly(Side.CLIENT) public AxisAlignedBB getRenderBoundingBox() diff --git a/src/main/java/mekanism/common/tile/TileEntitySolarEvaporationController.java b/src/main/java/mekanism/common/tile/TileEntitySolarEvaporationController.java index f86014277..c35b04b48 100644 --- a/src/main/java/mekanism/common/tile/TileEntitySolarEvaporationController.java +++ b/src/main/java/mekanism/common/tile/TileEntitySolarEvaporationController.java @@ -758,10 +758,7 @@ public class TileEntitySolarEvaporationController extends TileEntitySolarEvapora } @Override - public void setActive(boolean active) - { - - } + public void setActive(boolean active) {} @Override public boolean renderUpdate() diff --git a/src/main/java/mekanism/common/tile/TileEntityStructuralGlass.java b/src/main/java/mekanism/common/tile/TileEntityStructuralGlass.java new file mode 100644 index 000000000..b13dd889c --- /dev/null +++ b/src/main/java/mekanism/common/tile/TileEntityStructuralGlass.java @@ -0,0 +1,111 @@ +package mekanism.common.tile; + +import java.util.HashSet; +import java.util.Set; + +import mekanism.api.Coord4D; +import mekanism.common.multiblock.IMultiblock; +import mekanism.common.multiblock.IStructuralMultiblock; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.tileentity.TileEntity; +import net.minecraftforge.common.util.ForgeDirection; + +public class TileEntityStructuralGlass extends TileEntity implements IStructuralMultiblock +{ + public Coord4D master; + + @Override + public boolean onActivate(EntityPlayer player) + { + if(master != null) + { + if(master.getTileEntity(worldObj) instanceof IMultiblock) + { + return ((IMultiblock)master.getTileEntity(worldObj)).onActivate(player); + } + else { + master = null; + } + } + + return false; + } + + @Override + public void update() + { + if(master != null) + { + if(master.getTileEntity(worldObj) instanceof IMultiblock) + { + ((IMultiblock)master.getTileEntity(worldObj)).update(); + } + else { + master = null; + } + } + else { + IMultiblock multiblock = new ControllerFinder().find(); + + if(multiblock != null) + { + multiblock.update(); + } + } + } + + @Override + public boolean canInterface(TileEntity controller) + { + return true; + } + + @Override + public void setController(Coord4D coord) + { + master = coord; + } + + public class ControllerFinder + { + public IMultiblock found; + + public Set iterated = new HashSet(); + + public void loop(Coord4D pos) + { + if(iterated.size() > 512 || found != null) + { + return; + } + + iterated.add(pos); + + for(ForgeDirection side : ForgeDirection.VALID_DIRECTIONS) + { + Coord4D coord = pos.getFromSide(side); + TileEntity tile = coord.getTileEntity(worldObj); + + if(!iterated.contains(coord)) + { + if(tile instanceof IMultiblock) + { + found = (IMultiblock)coord.getTileEntity(worldObj); + return; + } + else if(tile instanceof IStructuralMultiblock) + { + loop(coord); + } + } + } + } + + public IMultiblock find() + { + loop(Coord4D.get(TileEntityStructuralGlass.this)); + + return found; + } + } +} diff --git a/src/main/java/mekanism/generators/client/BlockRenderingHandler.java b/src/main/java/mekanism/generators/client/BlockRenderingHandler.java index a5a97c4fd..527e36c01 100644 --- a/src/main/java/mekanism/generators/client/BlockRenderingHandler.java +++ b/src/main/java/mekanism/generators/client/BlockRenderingHandler.java @@ -100,18 +100,7 @@ public class BlockRenderingHandler implements ISimpleBlockRenderingHandler @Override public boolean renderWorldBlock(IBlockAccess world, int x, int y, int z, Block block, int modelId, RenderBlocks renderer) { - if(block == GeneratorsBlocks.Generator) - { - int metadata = world.getBlockMetadata(x, y, z); - - if(GeneratorType.getFromMetadata(metadata) == null || !GeneratorType.getFromMetadata(metadata).hasModel) - { - renderer.renderStandardBlock(block, x, y, z); - renderer.setRenderBoundsFromBlock(block); - return true; - } - } - + //Handled by CTMRenderingHandler return false; } diff --git a/src/main/java/mekanism/generators/client/GeneratorsClientProxy.java b/src/main/java/mekanism/generators/client/GeneratorsClientProxy.java index 3422806b3..c86cd4412 100644 --- a/src/main/java/mekanism/generators/client/GeneratorsClientProxy.java +++ b/src/main/java/mekanism/generators/client/GeneratorsClientProxy.java @@ -3,6 +3,7 @@ package mekanism.generators.client; import mekanism.generators.client.gui.GuiBioGenerator; import mekanism.generators.client.gui.GuiGasGenerator; import mekanism.generators.client.gui.GuiHeatGenerator; +import mekanism.generators.client.gui.GuiIndustrialTurbine; import mekanism.generators.client.gui.GuiNeutronCapture; import mekanism.generators.client.gui.GuiReactorController; import mekanism.generators.client.gui.GuiReactorFuel; @@ -15,10 +16,13 @@ import mekanism.generators.client.render.RenderAdvancedSolarGenerator; import mekanism.generators.client.render.RenderBioGenerator; import mekanism.generators.client.render.RenderGasGenerator; import mekanism.generators.client.render.RenderHeatGenerator; +import mekanism.generators.client.render.RenderIndustrialTurbine; import mekanism.generators.client.render.RenderReactor; import mekanism.generators.client.render.RenderSolarGenerator; -import mekanism.generators.client.render.RenderTurbineRod; +import mekanism.generators.client.render.RenderTurbineRotor; import mekanism.generators.client.render.RenderWindTurbine; +import mekanism.generators.client.render.item.GeneratorsItemRenderer; +import mekanism.generators.common.GeneratorsBlocks; import mekanism.generators.common.GeneratorsCommonProxy; import mekanism.generators.common.tile.TileEntityAdvancedSolarGenerator; import mekanism.generators.common.tile.TileEntityBioGenerator; @@ -29,13 +33,21 @@ import mekanism.generators.common.tile.TileEntityWindGenerator; import mekanism.generators.common.tile.reactor.TileEntityReactorController; import mekanism.generators.common.tile.reactor.TileEntityReactorLogicAdapter; import mekanism.generators.common.tile.reactor.TileEntityReactorNeutronCapture; -import mekanism.generators.common.tile.turbine.TileEntityTurbineRod; +import mekanism.generators.common.tile.turbine.TileEntityTurbineCasing; +import mekanism.generators.common.tile.turbine.TileEntityTurbineRotor; +import mekanism.generators.common.tile.turbine.TileEntityTurbineValve; +import mekanism.generators.common.tile.turbine.TileEntityTurbineVent; import net.minecraft.client.gui.GuiScreen; import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.item.Item; import net.minecraft.tileentity.TileEntity; import net.minecraft.world.World; +import net.minecraftforge.client.MinecraftForgeClient; +import net.minecraftforge.client.event.TextureStitchEvent; +import net.minecraftforge.common.MinecraftForge; import net.minecraftforge.fml.client.registry.ClientRegistry; import net.minecraftforge.fml.client.registry.RenderingRegistry; +import net.minecraftforge.fml.common.eventhandler.SubscribeEvent; import net.minecraftforge.fml.relauncher.Side; import net.minecraftforge.fml.relauncher.SideOnly; @@ -52,7 +64,10 @@ public class GeneratorsClientProxy extends GeneratorsCommonProxy ClientRegistry.registerTileEntity(TileEntityGasGenerator.class, "GasGenerator", new RenderGasGenerator()); ClientRegistry.registerTileEntity(TileEntityWindGenerator.class, "WindTurbine", new RenderWindTurbine()); ClientRegistry.registerTileEntity(TileEntityReactorController.class, "ReactorController", new RenderReactor()); - ClientRegistry.registerTileEntity(TileEntityTurbineRod.class, "TurbineRod", new RenderTurbineRod()); + ClientRegistry.registerTileEntity(TileEntityTurbineRotor.class, "TurbineRod", new RenderTurbineRotor()); + ClientRegistry.registerTileEntity(TileEntityTurbineCasing.class, "TurbineCasing", new RenderIndustrialTurbine()); + ClientRegistry.registerTileEntity(TileEntityTurbineValve.class, "TurbineValve", new RenderIndustrialTurbine()); + ClientRegistry.registerTileEntity(TileEntityTurbineVent.class, "TurbineVent", new RenderIndustrialTurbine()); } @Override @@ -60,6 +75,13 @@ public class GeneratorsClientProxy extends GeneratorsCommonProxy { //Register block handler RenderingRegistry.registerBlockHandler(new BlockRenderingHandler()); + + //Register item handler + GeneratorsItemRenderer handler = new GeneratorsItemRenderer(); + + MinecraftForge.EVENT_BUS.register(this); + + MinecraftForgeClient.registerItemRenderer(Item.getItemFromBlock(GeneratorsBlocks.Generator), handler); System.out.println("[MekanismGenerators] Render registrations complete."); } @@ -81,6 +103,8 @@ public class GeneratorsClientProxy extends GeneratorsCommonProxy return new GuiBioGenerator(player.inventory, (TileEntityBioGenerator)tileEntity); case 5: return new GuiWindGenerator(player.inventory, (TileEntityWindGenerator)tileEntity); + case 6: + return new GuiIndustrialTurbine(player.inventory, (TileEntityTurbineCasing)tileEntity); case 10: return new GuiReactorController(player.inventory, (TileEntityReactorController)tileEntity); case 11: @@ -97,4 +121,10 @@ public class GeneratorsClientProxy extends GeneratorsCommonProxy return null; } + + @SubscribeEvent + public void onStitch(TextureStitchEvent.Pre event) + { + RenderIndustrialTurbine.resetDisplayInts(); + } } diff --git a/src/main/java/mekanism/generators/client/gui/GuiIndustrialTurbine.java b/src/main/java/mekanism/generators/client/gui/GuiIndustrialTurbine.java new file mode 100644 index 000000000..4915e7c84 --- /dev/null +++ b/src/main/java/mekanism/generators/client/gui/GuiIndustrialTurbine.java @@ -0,0 +1,20 @@ +package mekanism.generators.client.gui; + +import mekanism.client.gui.GuiMekanism; +import mekanism.common.inventory.container.ContainerFilter; +import mekanism.generators.common.tile.turbine.TileEntityTurbineCasing; +import net.minecraft.entity.player.InventoryPlayer; +import cpw.mods.fml.relauncher.Side; +import cpw.mods.fml.relauncher.SideOnly; + +@SideOnly(Side.CLIENT) +public class GuiIndustrialTurbine extends GuiMekanism +{ + public TileEntityTurbineCasing tileEntity; + + public GuiIndustrialTurbine(InventoryPlayer inventory, TileEntityTurbineCasing tentity) + { + super(tentity, new ContainerFilter(inventory, tentity)); + tileEntity = tentity; + } +} diff --git a/src/main/java/mekanism/generators/client/render/RenderIndustrialTurbine.java b/src/main/java/mekanism/generators/client/render/RenderIndustrialTurbine.java new file mode 100644 index 000000000..d18e93929 --- /dev/null +++ b/src/main/java/mekanism/generators/client/render/RenderIndustrialTurbine.java @@ -0,0 +1,148 @@ +package mekanism.generators.client.render; + +import java.util.HashMap; +import java.util.Map; + +import mekanism.client.render.MekanismRenderer; +import mekanism.client.render.MekanismRenderer.DisplayInteger; +import mekanism.client.render.MekanismRenderer.Model3D; +import mekanism.client.render.tileentity.RenderDynamicTank.RenderData; +import mekanism.common.content.tank.TankUpdateProtocol; +import mekanism.generators.common.tile.turbine.TileEntityTurbineCasing; +import net.minecraft.client.renderer.tileentity.TileEntityRendererDispatcher; +import net.minecraft.client.renderer.tileentity.TileEntitySpecialRenderer; +import net.minecraft.init.Blocks; +import net.minecraft.tileentity.TileEntity; +import net.minecraft.world.World; +import net.minecraftforge.fluids.Fluid; +import net.minecraftforge.fluids.FluidRegistry; + +import org.lwjgl.opengl.GL11; + +public class RenderIndustrialTurbine extends TileEntitySpecialRenderer +{ + private static Map cachedFluids = new HashMap(); + + private Fluid STEAM = FluidRegistry.getFluid("steam"); + + @Override + public void renderTileEntityAt(TileEntity tileEntity, double x, double y, double z, float partialTick) + { + renderAModelAt((TileEntityTurbineCasing)tileEntity, x, y, z, partialTick); + } + + public void renderAModelAt(TileEntityTurbineCasing tileEntity, double x, double y, double z, float partialTick) + { + if(tileEntity.clientHasStructure && tileEntity.isRendering && tileEntity.structure != null && tileEntity.structure.fluidStored != null && tileEntity.structure.fluidStored.amount != 0) + { + RenderData data = new RenderData(); + + data.location = tileEntity.structure.renderLocation; + data.height = tileEntity.structure.lowerVolume/(tileEntity.structure.volLength*tileEntity.structure.volWidth); + data.length = tileEntity.structure.volLength; + data.width = tileEntity.structure.volWidth; + + bindTexture(MekanismRenderer.getBlocksTexture()); + + if(data.location != null && data.height >= 3 && tileEntity.structure.fluidStored.getFluid() != null) + { + push(); + + GL11.glTranslated(getX(data.location.xCoord), getY(data.location.yCoord), getZ(data.location.zCoord)); + + MekanismRenderer.glowOn(tileEntity.structure.fluidStored.getFluid().getLuminosity()); + MekanismRenderer.colorFluid(tileEntity.structure.fluidStored.getFluid()); + + DisplayInteger[] displayList = getListAndRender(data, tileEntity.getWorldObj()); + + GL11.glColor4f(1F, 1F, 1F, Math.min(1, ((float)tileEntity.structure.fluidStored.amount / (float)tileEntity.structure.getFluidCapacity())+0.3F)); + displayList[getStages(data.height)-1].render(); + + MekanismRenderer.glowOff(); + MekanismRenderer.resetColor(); + + pop(); + } + } + } + + private void pop() + { + GL11.glPopAttrib(); + GL11.glPopMatrix(); + } + + private void push() + { + GL11.glPushMatrix(); + GL11.glPushAttrib(GL11.GL_ENABLE_BIT); + GL11.glEnable(GL11.GL_CULL_FACE); + GL11.glEnable(GL11.GL_BLEND); + GL11.glDisable(GL11.GL_LIGHTING); + GL11.glBlendFunc(GL11.GL_SRC_ALPHA, GL11.GL_ONE_MINUS_SRC_ALPHA); + } + + private int getStages(int height) + { + return (height-2)*(TankUpdateProtocol.FLUID_PER_TANK/10); + } + + private double getX(int x) + { + return x - TileEntityRendererDispatcher.staticPlayerX; + } + + private double getY(int y) + { + return y - TileEntityRendererDispatcher.staticPlayerY; + } + + private double getZ(int z) + { + return z - TileEntityRendererDispatcher.staticPlayerZ; + } + + private DisplayInteger[] getListAndRender(RenderData data, World world) + { + if(cachedFluids.containsKey(data)) + { + return cachedFluids.get(data); + } + + Model3D toReturn = new Model3D(); + toReturn.baseBlock = Blocks.water; + toReturn.setTexture(STEAM.getIcon()); + + final int stages = getStages(data.height); + DisplayInteger[] displays = new DisplayInteger[stages]; + + cachedFluids.put(data, displays); + + for(int i = 0; i < stages; i++) + { + displays[i] = DisplayInteger.createAndStart(); + + if(STEAM.getIcon() != null) + { + toReturn.minX = 0 + .01; + toReturn.minY = 0 + .01; + toReturn.minZ = 0 + .01; + + toReturn.maxX = data.length - .01; + toReturn.maxY = ((float)i/(float)stages)*(data.height-2) - .01; + toReturn.maxZ = data.width - .01; + + MekanismRenderer.renderObject(toReturn); + } + + GL11.glEndList(); + } + + return displays; + } + + public static void resetDisplayInts() + { + cachedFluids.clear(); + } +} diff --git a/src/main/java/mekanism/generators/client/render/RenderTurbineRod.java b/src/main/java/mekanism/generators/client/render/RenderTurbineRotor.java similarity index 88% rename from src/main/java/mekanism/generators/client/render/RenderTurbineRod.java rename to src/main/java/mekanism/generators/client/render/RenderTurbineRotor.java index fd4ce3669..5313848f6 100644 --- a/src/main/java/mekanism/generators/client/render/RenderTurbineRod.java +++ b/src/main/java/mekanism/generators/client/render/RenderTurbineRotor.java @@ -5,7 +5,7 @@ import mekanism.common.util.MekanismUtils; import mekanism.common.util.MekanismUtils.ResourceType; import mekanism.generators.client.model.ModelTurbine; import mekanism.generators.common.tile.turbine.TileEntityRotationalComplex; -import mekanism.generators.common.tile.turbine.TileEntityTurbineRod; +import mekanism.generators.common.tile.turbine.TileEntityTurbineRotor; import net.minecraft.client.renderer.tileentity.TileEntitySpecialRenderer; import net.minecraft.tileentity.TileEntity; @@ -15,7 +15,7 @@ import cpw.mods.fml.relauncher.Side; import cpw.mods.fml.relauncher.SideOnly; @SideOnly(Side.CLIENT) -public class RenderTurbineRod extends TileEntitySpecialRenderer +public class RenderTurbineRotor extends TileEntitySpecialRenderer { private ModelTurbine model = new ModelTurbine(); @@ -24,10 +24,10 @@ public class RenderTurbineRod extends TileEntitySpecialRenderer @Override public void renderTileEntityAt(TileEntity tileEntity, double x, double y, double z, float partialTick) { - renderAModelAt((TileEntityTurbineRod)tileEntity, x, y, z, partialTick); + renderAModelAt((TileEntityTurbineRotor)tileEntity, x, y, z, partialTick); } - private void renderAModelAt(TileEntityTurbineRod tileEntity, double x, double y, double z, float partialTick) + private void renderAModelAt(TileEntityTurbineRotor tileEntity, double x, double y, double z, float partialTick) { GL11.glPushMatrix(); diff --git a/src/main/java/mekanism/generators/client/render/item/GeneratorsItemRenderer.java b/src/main/java/mekanism/generators/client/render/item/GeneratorsItemRenderer.java new file mode 100644 index 000000000..d233e4906 --- /dev/null +++ b/src/main/java/mekanism/generators/client/render/item/GeneratorsItemRenderer.java @@ -0,0 +1,46 @@ +package mekanism.generators.client.render.item; + +import mekanism.generators.client.GeneratorsClientProxy; +import mekanism.generators.common.item.ItemBlockGenerator; +import net.minecraft.block.Block; +import net.minecraft.client.renderer.RenderBlocks; +import net.minecraft.item.ItemStack; +import net.minecraftforge.client.IItemRenderer; + +import org.lwjgl.opengl.GL11; + +import cpw.mods.fml.client.registry.RenderingRegistry; +import cpw.mods.fml.relauncher.Side; +import cpw.mods.fml.relauncher.SideOnly; + +@SideOnly(Side.CLIENT) +public class GeneratorsItemRenderer implements IItemRenderer +{ + @Override + public boolean handleRenderType(ItemStack item, ItemRenderType type) + { + return true; + } + + @Override + public boolean shouldUseRenderHelper(ItemRenderType type, ItemStack item, ItemRendererHelper helper) + { + return true; + } + + @Override + public void renderItem(ItemRenderType type, ItemStack item, Object... data) + { + RenderBlocks renderBlocks = (RenderBlocks)data[0]; + + if(type == ItemRenderType.EQUIPPED || type == ItemRenderType.EQUIPPED_FIRST_PERSON) + { + GL11.glTranslatef(0.5F, 0.5F, 0.5F); + } + + if(item.getItem() instanceof ItemBlockGenerator) + { + RenderingRegistry.instance().renderInventoryBlock((RenderBlocks)data[0], Block.getBlockFromItem(item.getItem()), item.getItemDamage(), GeneratorsClientProxy.GENERATOR_RENDER_ID); + } + } +} diff --git a/src/main/java/mekanism/generators/common/GeneratorsCommonProxy.java b/src/main/java/mekanism/generators/common/GeneratorsCommonProxy.java index 7f88b7bc7..b79c27d64 100644 --- a/src/main/java/mekanism/generators/common/GeneratorsCommonProxy.java +++ b/src/main/java/mekanism/generators/common/GeneratorsCommonProxy.java @@ -2,6 +2,7 @@ package mekanism.generators.common; import mekanism.api.MekanismConfig.generators; import mekanism.common.Mekanism; +import mekanism.common.inventory.container.ContainerFilter; import mekanism.common.inventory.container.ContainerNull; import mekanism.common.tile.TileEntityContainerBlock; import mekanism.generators.common.inventory.container.ContainerBioGenerator; @@ -24,8 +25,13 @@ import mekanism.generators.common.tile.reactor.TileEntityReactorLaserFocusMatrix import mekanism.generators.common.tile.reactor.TileEntityReactorLogicAdapter; import mekanism.generators.common.tile.reactor.TileEntityReactorNeutronCapture; import mekanism.generators.common.tile.reactor.TileEntityReactorPort; +import mekanism.generators.common.tile.turbine.TileEntityElectromagneticCoil; +import mekanism.generators.common.tile.turbine.TileEntityPressureDisperser; import mekanism.generators.common.tile.turbine.TileEntityRotationalComplex; -import mekanism.generators.common.tile.turbine.TileEntityTurbineRod; +import mekanism.generators.common.tile.turbine.TileEntityTurbineCasing; +import mekanism.generators.common.tile.turbine.TileEntityTurbineRotor; +import mekanism.generators.common.tile.turbine.TileEntityTurbineValve; +import mekanism.generators.common.tile.turbine.TileEntityTurbineVent; import net.minecraft.entity.player.EntityPlayer; import net.minecraft.inventory.Container; import net.minecraft.tileentity.TileEntity; @@ -54,6 +60,8 @@ public class GeneratorsCommonProxy GameRegistry.registerTileEntity(TileEntityReactorPort.class, "ReactorPort"); GameRegistry.registerTileEntity(TileEntityReactorLogicAdapter.class, "ReactorLogicAdapter"); GameRegistry.registerTileEntity(TileEntityRotationalComplex.class, "RotationalComplex"); + GameRegistry.registerTileEntity(TileEntityPressureDisperser.class, "PressureDisperser"); + GameRegistry.registerTileEntity(TileEntityElectromagneticCoil.class, "ElectromagneticCoil"); } /** @@ -68,7 +76,10 @@ public class GeneratorsCommonProxy GameRegistry.registerTileEntity(TileEntityGasGenerator.class, "GasGenerator"); GameRegistry.registerTileEntity(TileEntityWindGenerator.class, "WindTurbine"); GameRegistry.registerTileEntity(TileEntityReactorController.class, "ReactorController"); - GameRegistry.registerTileEntity(TileEntityTurbineRod.class, "TurbineRod"); + GameRegistry.registerTileEntity(TileEntityTurbineRotor.class, "TurbineRod"); + GameRegistry.registerTileEntity(TileEntityTurbineCasing.class, "TurbineCasing"); + GameRegistry.registerTileEntity(TileEntityTurbineValve.class, "TurbineValve"); + GameRegistry.registerTileEntity(TileEntityTurbineVent.class, "TurbineVent"); } /** @@ -162,6 +173,8 @@ public class GeneratorsCommonProxy return new ContainerBioGenerator(player.inventory, (TileEntityBioGenerator)tileEntity); case 5: return new ContainerWindGenerator(player.inventory, (TileEntityWindGenerator)tileEntity); + case 6: + return new ContainerFilter(player.inventory, (TileEntityTurbineCasing)tileEntity); case 10: return new ContainerReactorController(player.inventory, (TileEntityReactorController)tileEntity); case 11: diff --git a/src/main/java/mekanism/generators/common/GeneratorsItems.java b/src/main/java/mekanism/generators/common/GeneratorsItems.java index f2168ebcc..7b08407fd 100644 --- a/src/main/java/mekanism/generators/common/GeneratorsItems.java +++ b/src/main/java/mekanism/generators/common/GeneratorsItems.java @@ -2,7 +2,10 @@ package mekanism.generators.common; import mekanism.common.item.ItemMekanism; import mekanism.generators.common.item.ItemHohlraum; +import mekanism.generators.common.tile.turbine.TileEntityTurbineRotor; +import net.minecraft.entity.player.EntityPlayer; import net.minecraft.item.Item; +import net.minecraft.world.World; import net.minecraftforge.fml.common.registry.GameRegistry; import net.minecraftforge.fml.common.registry.GameRegistry.ObjectHolder; @@ -11,7 +14,13 @@ public class GeneratorsItems { public static final Item SolarPanel = new ItemMekanism().setUnlocalizedName("SolarPanel"); public static final ItemHohlraum Hohlraum = (ItemHohlraum)new ItemHohlraum().setUnlocalizedName("Hohlraum"); - public static final Item TurbineBlade = new ItemMekanism().setUnlocalizedName("TurbineBlade"); + public static final Item TurbineBlade = new ItemMekanism() { + @Override + public boolean doesSneakBypassUse(World world, int x, int y, int z, EntityPlayer player) + { + return world.getTileEntity(x, y, z) instanceof TileEntityTurbineRotor; + } + }.setUnlocalizedName("TurbineBlade"); public static void register() { diff --git a/src/main/java/mekanism/generators/common/MekanismGenerators.java b/src/main/java/mekanism/generators/common/MekanismGenerators.java index ca2880594..c4552e60e 100644 --- a/src/main/java/mekanism/generators/common/MekanismGenerators.java +++ b/src/main/java/mekanism/generators/common/MekanismGenerators.java @@ -1,5 +1,32 @@ package mekanism.generators.common; +import io.netty.buffer.ByteBuf; + +import java.io.IOException; + +import mekanism.api.MekanismConfig.general; +import mekanism.api.MekanismConfig.generators; +import mekanism.api.gas.Gas; +import mekanism.api.gas.GasRegistry; +import mekanism.api.infuse.InfuseRegistry; +import mekanism.common.FuelHandler; +import mekanism.common.Mekanism; +import mekanism.common.MekanismBlocks; +import mekanism.common.MekanismItems; +import mekanism.common.Tier.BaseTier; +import mekanism.common.Version; +import mekanism.common.base.IModule; +import mekanism.common.multiblock.MultiblockManager; +import mekanism.common.recipe.RecipeHandler; +import mekanism.common.recipe.ShapedMekanismRecipe; +import mekanism.common.util.MekanismUtils; +import mekanism.generators.common.content.turbine.SynchronizedTurbineData; +import net.minecraft.init.Blocks; +import net.minecraft.item.ItemStack; +import net.minecraft.item.crafting.CraftingManager; +import net.minecraftforge.fluids.FluidContainerRegistry; +import net.minecraftforge.fluids.FluidRegistry; +import net.minecraftforge.oredict.OreDictionary; import buildcraft.api.fuels.BuildcraftFuelRegistry; import buildcraft.api.fuels.IFuel; import net.minecraftforge.fml.client.event.ConfigChangedEvent.OnConfigChangedEvent; @@ -13,26 +40,6 @@ import net.minecraftforge.fml.common.event.FMLPostInitializationEvent; import net.minecraftforge.fml.common.event.FMLPreInitializationEvent; import net.minecraftforge.fml.common.eventhandler.SubscribeEvent; import net.minecraftforge.fml.common.network.NetworkRegistry; -import io.netty.buffer.ByteBuf; -import mekanism.api.MekanismConfig.general; -import mekanism.api.MekanismConfig.generators; -import mekanism.api.gas.Gas; -import mekanism.api.gas.GasRegistry; -import mekanism.api.infuse.InfuseRegistry; -import mekanism.common.*; -import mekanism.common.Tier.BaseTier; -import mekanism.common.base.IModule; -import mekanism.common.recipe.ShapedMekanismRecipe; -import mekanism.common.recipe.RecipeHandler; -import mekanism.common.util.MekanismUtils; -import net.minecraft.init.Blocks; -import net.minecraft.item.ItemStack; -import net.minecraft.item.crafting.CraftingManager; -import net.minecraftforge.fluids.FluidContainerRegistry; -import net.minecraftforge.fluids.FluidRegistry; -import net.minecraftforge.oredict.OreDictionary; - -import java.io.IOException; @Mod(modid = "MekanismGenerators", name = "MekanismGenerators", version = "9.0.0", dependencies = "required-after:Mekanism", guiFactory = "mekanism.generators.client.gui.GeneratorsGuiFactory") public class MekanismGenerators implements IModule @@ -48,6 +55,8 @@ public class MekanismGenerators implements IModule /** MekanismGenerators version number */ public static Version versionNumber = new Version(9, 0, 0); + + public static MultiblockManager turbineManager = new MultiblockManager("industrialTurbine"); @EventHandler public void preInit(FMLPreInitializationEvent event) diff --git a/src/main/java/mekanism/generators/common/block/BlockGenerator.java b/src/main/java/mekanism/generators/common/block/BlockGenerator.java index 1760c6974..7969f22ea 100644 --- a/src/main/java/mekanism/generators/common/block/BlockGenerator.java +++ b/src/main/java/mekanism/generators/common/block/BlockGenerator.java @@ -1,18 +1,22 @@ package mekanism.generators.common.block; -import buildcraft.api.tools.IToolWrench; -import net.minecraftforge.fml.relauncher.Side; -import net.minecraftforge.fml.relauncher.SideOnly; +import java.util.Arrays; +import java.util.List; +import java.util.Random; + import mekanism.api.MekanismConfig.general; import mekanism.api.energy.IEnergizedItem; +import mekanism.common.CTMData; import mekanism.common.ItemAttacher; import mekanism.common.Mekanism; import mekanism.common.base.IActiveState; +import mekanism.common.base.IBlockCTM; import mekanism.common.base.IBoundingBlock; import mekanism.common.base.ISpecialBounds; import mekanism.common.base.ISustainedData; import mekanism.common.base.ISustainedInventory; import mekanism.common.base.ISustainedTank; +import mekanism.common.multiblock.IMultiblock; import mekanism.common.tile.TileEntityBasicBlock; import mekanism.common.tile.TileEntityContainerBlock; import mekanism.common.tile.TileEntityElectricBlock; @@ -27,8 +31,13 @@ import mekanism.generators.common.tile.TileEntityGasGenerator; import mekanism.generators.common.tile.TileEntityHeatGenerator; import mekanism.generators.common.tile.TileEntitySolarGenerator; import mekanism.generators.common.tile.TileEntityWindGenerator; +import mekanism.generators.common.tile.turbine.TileEntityElectromagneticCoil; +import mekanism.generators.common.tile.turbine.TileEntityPressureDisperser; import mekanism.generators.common.tile.turbine.TileEntityRotationalComplex; -import mekanism.generators.common.tile.turbine.TileEntityTurbineRod; +import mekanism.generators.common.tile.turbine.TileEntityTurbineCasing; +import mekanism.generators.common.tile.turbine.TileEntityTurbineRotor; +import mekanism.generators.common.tile.turbine.TileEntityTurbineValve; +import mekanism.generators.common.tile.turbine.TileEntityTurbineVent; import net.minecraft.block.Block; import net.minecraft.block.BlockContainer; import net.minecraft.block.material.Material; @@ -46,9 +55,9 @@ import net.minecraft.util.MovingObjectPosition; import net.minecraft.world.IBlockAccess; import net.minecraft.world.World; import net.minecraft.util.EnumFacing; - -import java.util.List; -import java.util.Random; +import buildcraft.api.tools.IToolWrench; +import net.minecraftforge.fml.relauncher.Side; +import net.minecraftforge.fml.relauncher.SideOnly; /** @@ -59,14 +68,22 @@ import java.util.Random; * 4: Bio-Generator * 5: Advanced Solar Generator * 6: Wind Generator - * 7: Turbine Rod + * 7: Turbine Rotor * 8: Rotational Complex + * 9: Pressure Disperser + * 10: Electromagnetic Coil + * 11: Turbine Casing + * 12: Turbine Valve + * 13: Turbine Vent * @author AidanBrady * */ -public class BlockGenerator extends BlockContainer implements ISpecialBounds +public class BlockGenerator extends BlockContainer implements ISpecialBounds, IBlockCTM { public IIcon[][] icons = new IIcon[16][16]; + + public CTMData[] ctms = new CTMData[16]; + public IIcon BASE_ICON; public Random machineRand = new Random(); @@ -84,24 +101,58 @@ public class BlockGenerator extends BlockContainer implements ISpecialBounds public void registerBlockIcons(IIconRegister register) { BASE_ICON = register.registerIcon("mekanism:SteelCasing"); + + ctms[10] = new CTMData("ctm/ElectromagneticCoil", this, Arrays.asList(10)).registerIcons(register); + ctms[11] = new CTMData("ctm/TurbineCasing", this, Arrays.asList(11, 12, 13)).registerIcons(register); + ctms[12] = new CTMData("ctm/TurbineValve", this, Arrays.asList(11, 12, 13)).registerIcons(register); + ctms[13] = new CTMData("ctm/TurbineVent", this, Arrays.asList(11, 12, 13)).registerIcons(register); + icons[7][0] = register.registerIcon("mekanism:TurbineRod"); - icons[8][0] = register.registerIcon("mekanism:TurbineRod"); + icons[8][0] = register.registerIcon("mekanism:RotationalComplexSide"); + icons[8][1] = register.registerIcon("mekanism:RotationalComplexTop"); + icons[9][0] = register.registerIcon("mekanism:PressureDisperser"); + + icons[10][0] = ctms[10].mainTextureData.icon; + icons[11][0] = ctms[11].mainTextureData.icon; + icons[12][0] = ctms[12].mainTextureData.icon; + icons[13][0] = ctms[13].mainTextureData.icon; + } + + @Override + public CTMData getCTMData(IBlockAccess world, int x, int y, int z, int meta) + { + return ctms[meta]; + } + + @Override + public boolean shouldRenderBlock(IBlockAccess world, int x, int y, int z, int meta) + { + return !GeneratorType.getFromMetadata(meta).hasModel; } @Override @SideOnly(Side.CLIENT) public IIcon getIcon(int side, int meta) { - if(meta == GeneratorType.TURBINE_ROD.meta) - { - return icons[meta][0]; - } - else if(meta == GeneratorType.ROTATIONAL_COMPLEX.meta) - { - return icons[meta][0]; - } + GeneratorType type = GeneratorType.getFromMetadata(meta); - return BASE_ICON; + if(type == GeneratorType.ROTATIONAL_COMPLEX) + { + if(side != 0 && side != 1) + { + return icons[meta][0]; + } + else { + return icons[meta][1]; + } + } + else if(!type.hasModel) + { + return icons[meta][0]; + } + else { + return BASE_ICON; + } } @Override @@ -119,6 +170,11 @@ public class BlockGenerator extends BlockContainer implements ISpecialBounds if(!world.isRemote) { TileEntity tileEntity = world.getTileEntity(x, y, z); + + if(tileEntity instanceof IMultiblock) + { + ((IMultiblock)tileEntity).update(); + } if(tileEntity instanceof TileEntityBasicBlock) { @@ -166,6 +222,11 @@ public class BlockGenerator extends BlockContainer implements ISpecialBounds { ((IBoundingBlock)tileEntity).onPlace(); } + + if(!world.isRemote && tileEntity instanceof IMultiblock) + { + ((IMultiblock)tileEntity).update(); + } } @Override @@ -326,9 +387,9 @@ public class BlockGenerator extends BlockContainer implements ISpecialBounds { TileEntityBasicBlock tileEntity = (TileEntityBasicBlock)world.getTileEntity(x, y, z); - if(!world.isRemote && tileEntity instanceof TileEntityTurbineRod) + if(!world.isRemote && tileEntity instanceof TileEntityTurbineRotor) { - int amount = ((TileEntityTurbineRod)tileEntity).getHousedBlades(); + int amount = ((TileEntityTurbineRotor)tileEntity).getHousedBlades(); if(amount > 0) { @@ -400,9 +461,14 @@ public class BlockGenerator extends BlockContainer implements ISpecialBounds } } - if(metadata == GeneratorType.TURBINE_ROD.meta) + if(metadata == GeneratorType.TURBINE_CASING.meta || metadata == GeneratorType.TURBINE_VALVE.meta || metadata == GeneratorType.TURBINE_VENT.meta) { - TileEntityTurbineRod rod = (TileEntityTurbineRod)tileEntity; + return ((IMultiblock)world.getTileEntity(x, y, z)).onActivate(entityplayer); + } + + if(metadata == GeneratorType.TURBINE_ROTOR.meta) + { + TileEntityTurbineRotor rod = (TileEntityTurbineRotor)tileEntity; if(!entityplayer.isSneaking()) { @@ -459,12 +525,14 @@ public class BlockGenerator extends BlockContainer implements ISpecialBounds return false; } + + int guiId = GeneratorType.getFromMetadata(metadata).guiId; - if(tileEntity != null) + if(guiId != -1 && tileEntity != null) { if(!entityplayer.isSneaking()) { - entityplayer.openGui(MekanismGenerators.instance, GeneratorType.getFromMetadata(metadata).guiId, world, x, y, z); + entityplayer.openGui(MekanismGenerators.instance, guiId, world, x, y, z); return true; } } @@ -512,7 +580,7 @@ public class BlockGenerator extends BlockContainer implements ISpecialBounds @Override public int getRenderType() { - return MekanismGenerators.proxy.GENERATOR_RENDER_ID; + return Mekanism.proxy.CTM_RENDER_ID; } /*This method is not used, metadata manipulation is required to create a Tile Entity.*/ @@ -531,7 +599,7 @@ public class BlockGenerator extends BlockContainer implements ISpecialBounds { setBlockBounds(0.0F, 0.0F, 0.0F, 1.0F, 0.65F, 1.0F); } - else if(metadata == GeneratorType.TURBINE_ROD.meta) + else if(metadata == GeneratorType.TURBINE_ROTOR.meta) { setBlockBounds(0.375F, 0.0F, 0.375F, 0.625F, 1.0F, 0.625F); } @@ -643,7 +711,7 @@ public class BlockGenerator extends BlockContainer implements ISpecialBounds if(metadata != GeneratorType.SOLAR_GENERATOR.meta && metadata != GeneratorType.ADVANCED_SOLAR_GENERATOR.meta && metadata != GeneratorType.WIND_GENERATOR.meta && - metadata != GeneratorType.TURBINE_ROD.meta) + metadata != GeneratorType.TURBINE_ROTOR.meta) { return true; } @@ -659,8 +727,13 @@ public class BlockGenerator extends BlockContainer implements ISpecialBounds BIO_GENERATOR(4, "BioGenerator", 4, 160000, TileEntityBioGenerator.class, true), ADVANCED_SOLAR_GENERATOR(5, "AdvancedSolarGenerator", 1, 200000, TileEntityAdvancedSolarGenerator.class, true), WIND_GENERATOR(6, "WindGenerator", 5, 200000, TileEntityWindGenerator.class, true), - TURBINE_ROD(7, "TurbineRod", -1, -1, TileEntityTurbineRod.class, false), - ROTATIONAL_COMPLEX(8, "RotationalComplex", -1, -1, TileEntityRotationalComplex.class, false); + TURBINE_ROTOR(7, "TurbineRotor", -1, -1, TileEntityTurbineRotor.class, false), + ROTATIONAL_COMPLEX(8, "RotationalComplex", -1, -1, TileEntityRotationalComplex.class, false), + PRESSURE_DISPERSER(9, "PressureDisperser", -1, -1, TileEntityPressureDisperser.class, false), + ELECTROMAGNETIC_COIL(10, "ElectromagneticCoil", -1, -1, TileEntityElectromagneticCoil.class, false), + TURBINE_CASING(11, "TurbineCasing", -1, -1, TileEntityTurbineCasing.class, false), + TURBINE_VALVE(12, "TurbineValve", -1, -1, TileEntityTurbineValve.class, false), + TURBINE_VENT(13, "TurbineVent", -1, -1, TileEntityTurbineVent.class, false); public int meta; public String name; @@ -727,7 +800,7 @@ public class BlockGenerator extends BlockContainer implements ISpecialBounds { block.setBlockBounds(0.0F, 0.0F, 0.0F, 1.0F, 0.65F, 1.0F); } - else if(metadata == GeneratorType.TURBINE_ROD.meta) + else if(metadata == GeneratorType.TURBINE_ROTOR.meta) { block.setBlockBounds(0.375F, 0.0F, 0.375F, 0.625F, 1.0F, 0.625F); } diff --git a/src/main/java/mekanism/generators/common/block/BlockReactor.java b/src/main/java/mekanism/generators/common/block/BlockReactor.java index 991d97214..a42f47b50 100644 --- a/src/main/java/mekanism/generators/common/block/BlockReactor.java +++ b/src/main/java/mekanism/generators/common/block/BlockReactor.java @@ -1,8 +1,8 @@ package mekanism.generators.common.block; -import buildcraft.api.tools.IToolWrench; -import net.minecraftforge.fml.relauncher.Side; -import net.minecraftforge.fml.relauncher.SideOnly; +import java.util.Arrays; +import java.util.List; + import mekanism.api.Coord4D; import mekanism.common.CTMData; import mekanism.common.ItemAttacher; @@ -14,7 +14,13 @@ import mekanism.common.util.LangUtils; import mekanism.common.util.MekanismUtils; import mekanism.generators.common.GeneratorsBlocks; import mekanism.generators.common.MekanismGenerators; -import mekanism.generators.common.tile.reactor.*; +import mekanism.generators.common.tile.reactor.TileEntityReactorController; +import mekanism.generators.common.tile.reactor.TileEntityReactorFrame; +import mekanism.generators.common.tile.reactor.TileEntityReactorGlass; +import mekanism.generators.common.tile.reactor.TileEntityReactorLaserFocusMatrix; +import mekanism.generators.common.tile.reactor.TileEntityReactorLogicAdapter; +import mekanism.generators.common.tile.reactor.TileEntityReactorNeutronCapture; +import mekanism.generators.common.tile.reactor.TileEntityReactorPort; import net.minecraft.block.Block; import net.minecraft.block.BlockContainer; import net.minecraft.block.material.Material; @@ -29,9 +35,9 @@ import net.minecraft.util.IIcon; import net.minecraft.world.IBlockAccess; import net.minecraft.world.World; import net.minecraft.util.EnumFacing; - -import java.util.Arrays; -import java.util.List; +import buildcraft.api.tools.IToolWrench; +import net.minecraftforge.fml.relauncher.Side; +import net.minecraftforge.fml.relauncher.SideOnly; public class BlockReactor extends BlockContainer implements IBlockCTM { @@ -304,6 +310,12 @@ public class BlockReactor extends BlockContainer implements IBlockCTM return ctms[meta][0]; } + + @Override + public boolean shouldRenderBlock(IBlockAccess world, int x, int y, int z, int meta) + { + return true; + } @Override @SideOnly(Side.CLIENT) diff --git a/src/main/java/mekanism/generators/common/content/turbine/SynchronizedTurbineData.java b/src/main/java/mekanism/generators/common/content/turbine/SynchronizedTurbineData.java new file mode 100644 index 000000000..e6f7a4ba3 --- /dev/null +++ b/src/main/java/mekanism/generators/common/content/turbine/SynchronizedTurbineData.java @@ -0,0 +1,47 @@ +package mekanism.generators.common.content.turbine; + +import mekanism.common.multiblock.SynchronizedData; +import net.minecraftforge.fluids.FluidStack; + +public class SynchronizedTurbineData extends SynchronizedData +{ + public FluidStack fluidStored; + + public FluidStack prevFluid; + + public double electricityStored; + + public int blades; + public int vents; + public int coils; + + public int lowerVolume; + + public int getFluidCapacity() + { + return lowerVolume*TurbineUpdateProtocol.FLUID_PER_TANK; + } + + public double getEnergyCapacity() + { + return volume*16000000; //16 MJ energy capacity per volume + } + + public boolean needsRenderUpdate() + { + if((fluidStored == null && prevFluid != null) || (fluidStored != null && prevFluid == null)) + { + return true; + } + + if(fluidStored != null && prevFluid != null) + { + if((fluidStored.getFluid() != prevFluid.getFluid()) || (fluidStored.amount != prevFluid.amount)) + { + return true; + } + } + + return false; + } +} diff --git a/src/main/java/mekanism/generators/common/content/turbine/TurbineCache.java b/src/main/java/mekanism/generators/common/content/turbine/TurbineCache.java new file mode 100644 index 000000000..550b8ebc6 --- /dev/null +++ b/src/main/java/mekanism/generators/common/content/turbine/TurbineCache.java @@ -0,0 +1,47 @@ +package mekanism.generators.common.content.turbine; + +import mekanism.common.multiblock.MultiblockCache; +import net.minecraft.nbt.NBTTagCompound; +import net.minecraftforge.fluids.FluidStack; + +public class TurbineCache extends MultiblockCache +{ + public FluidStack fluid; + public double electricity; + + @Override + public void apply(SynchronizedTurbineData data) + { + data.fluidStored = fluid; + data.electricityStored = electricity; + } + + @Override + public void sync(SynchronizedTurbineData data) + { + fluid = data.fluidStored; + electricity = data.electricityStored; + } + + @Override + public void load(NBTTagCompound nbtTags) + { + if(nbtTags.hasKey("cachedFluid")) + { + fluid = FluidStack.loadFluidStackFromNBT(nbtTags.getCompoundTag("cachedFluid")); + } + + electricity = nbtTags.getDouble("electricity"); + } + + @Override + public void save(NBTTagCompound nbtTags) + { + if(fluid != null) + { + nbtTags.setTag("cachedFluid", fluid.writeToNBT(new NBTTagCompound())); + } + + nbtTags.setDouble("electricity", electricity); + } +} diff --git a/src/main/java/mekanism/generators/common/content/turbine/TurbineFluidTank.java b/src/main/java/mekanism/generators/common/content/turbine/TurbineFluidTank.java new file mode 100644 index 000000000..c66b5b5d7 --- /dev/null +++ b/src/main/java/mekanism/generators/common/content/turbine/TurbineFluidTank.java @@ -0,0 +1,177 @@ +package mekanism.generators.common.content.turbine; + +import mekanism.common.util.MekanismUtils; +import mekanism.generators.common.tile.turbine.TileEntityTurbineCasing; +import net.minecraftforge.fluids.FluidStack; +import net.minecraftforge.fluids.FluidTankInfo; +import net.minecraftforge.fluids.IFluidTank; + +public class TurbineFluidTank implements IFluidTank +{ + public TileEntityTurbineCasing turbine; + + public TurbineFluidTank(TileEntityTurbineCasing tileEntity) + { + turbine = tileEntity; + } + + @Override + public FluidStack getFluid() + { + return turbine.structure != null ? turbine.structure.fluidStored : null; + } + + @Override + public int getCapacity() + { + return turbine.structure != null ? turbine.structure.getFluidCapacity() : 0; + } + + @Override + public int fill(FluidStack resource, boolean doFill) + { + if(turbine.structure != null && !turbine.getWorldObj().isRemote) + { + if(resource == null || resource.getFluidID() <= 0) + { + return 0; + } + + if(turbine.structure.fluidStored != null && !turbine.structure.fluidStored.isFluidEqual(resource)) + { + return 0; + } + + if(turbine.structure.fluidStored == null || turbine.structure.fluidStored.getFluidID() <= 0) + { + if(resource.amount <= getCapacity()) + { + if(doFill) + { + turbine.structure.fluidStored = resource.copy(); + + if(resource.amount > 0) + { + MekanismUtils.saveChunk(turbine); + } + } + + return resource.amount; + } + else { + if(doFill) + { + turbine.structure.fluidStored = resource.copy(); + turbine.structure.fluidStored.amount = getCapacity(); + + if(getCapacity() > 0) + { + MekanismUtils.saveChunk(turbine); + } + } + + return getCapacity(); + } + } + else if(resource.amount <= getNeeded()) + { + if(doFill) + { + turbine.structure.fluidStored.amount += resource.amount; + + if(resource.amount > 0) + { + MekanismUtils.saveChunk(turbine); + } + } + + return resource.amount; + } + else { + int prevNeeded = getNeeded(); + + if(doFill) + { + turbine.structure.fluidStored.amount = getCapacity(); + + if(prevNeeded > 0) + { + MekanismUtils.saveChunk(turbine); + } + } + + return prevNeeded; + } + } + + return 0; + } + + @Override + public FluidStack drain(int maxDrain, boolean doDrain) + { + if(turbine.structure != null && !turbine.getWorldObj().isRemote) + { + if(turbine.structure.fluidStored == null || turbine.structure.fluidStored.getFluidID() <= 0) + { + return null; + } + + if(turbine.structure.fluidStored.amount <= 0) + { + return null; + } + + int used = maxDrain; + + if(turbine.structure.fluidStored.amount < used) + { + used = turbine.structure.fluidStored.amount; + } + + if(doDrain) + { + turbine.structure.fluidStored.amount -= used; + } + + FluidStack drained = new FluidStack(turbine.structure.fluidStored.getFluid(), used); + + if(turbine.structure.fluidStored.amount <= 0) + { + turbine.structure.fluidStored = null; + } + + if(drained.amount > 0 && doDrain) + { + MekanismUtils.saveChunk(turbine); + turbine.sendPacketToRenderer(); + } + + return drained; + } + + return null; + } + + public int getNeeded() + { + return getCapacity()-getFluidAmount(); + } + + @Override + public int getFluidAmount() + { + if(turbine.structure != null) + { + return turbine.structure.fluidStored.amount; + } + + return 0; + } + + @Override + public FluidTankInfo getInfo() + { + return new FluidTankInfo(this); + } +} diff --git a/src/main/java/mekanism/generators/common/content/turbine/TurbineUpdateProtocol.java b/src/main/java/mekanism/generators/common/content/turbine/TurbineUpdateProtocol.java new file mode 100644 index 000000000..8d20ccd46 --- /dev/null +++ b/src/main/java/mekanism/generators/common/content/turbine/TurbineUpdateProtocol.java @@ -0,0 +1,292 @@ +package mekanism.generators.common.content.turbine; + +import java.util.HashSet; +import java.util.List; +import java.util.Set; + +import mekanism.api.Coord4D; +import mekanism.common.content.tank.TankUpdateProtocol; +import mekanism.common.multiblock.MultiblockCache; +import mekanism.common.multiblock.MultiblockManager; +import mekanism.common.multiblock.UpdateProtocol; +import mekanism.generators.common.GeneratorsBlocks; +import mekanism.generators.common.MekanismGenerators; +import mekanism.generators.common.block.BlockGenerator.GeneratorType; +import mekanism.generators.common.tile.turbine.TileEntityElectromagneticCoil; +import mekanism.generators.common.tile.turbine.TileEntityPressureDisperser; +import mekanism.generators.common.tile.turbine.TileEntityRotationalComplex; +import mekanism.generators.common.tile.turbine.TileEntityTurbineCasing; +import mekanism.generators.common.tile.turbine.TileEntityTurbineRotor; +import mekanism.generators.common.tile.turbine.TileEntityTurbineVent; +import net.minecraft.item.ItemStack; +import net.minecraft.tileentity.TileEntity; +import net.minecraftforge.common.util.ForgeDirection; + +public class TurbineUpdateProtocol extends UpdateProtocol +{ + public static final int FLUID_PER_TANK = TankUpdateProtocol.FLUID_PER_TANK; + + public TurbineUpdateProtocol(TileEntityTurbineCasing tileEntity) + { + super(tileEntity); + } + + @Override + protected boolean isValidFrame(int x, int y, int z) + { + return pointer.getWorldObj().getBlock(x, y, z) == GeneratorsBlocks.Generator && + GeneratorType.getFromMetadata(pointer.getWorldObj().getBlockMetadata(x, y, z)) == GeneratorType.TURBINE_CASING; + } + + @Override + protected boolean isValidInnerNode(int x, int y, int z) + { + if(super.isValidInnerNode(x, y, z)) + { + return true; + } + + TileEntity tile = pointer.getWorldObj().getTileEntity(x, y, z); + + return tile instanceof TileEntityTurbineRotor || tile instanceof TileEntityRotationalComplex || + tile instanceof TileEntityPressureDisperser || tile instanceof TileEntityElectromagneticCoil; + } + + @Override + public void killInnerNode(Coord4D coord) + { + TileEntity tile = coord.getTileEntity(pointer.getWorldObj()); + + if(tile instanceof TileEntityRotationalComplex) + { + ((TileEntityRotationalComplex)tile).setMultiblock(null); + } + } + + @Override + protected boolean canForm(SynchronizedTurbineData structure) + { + if(structure.volLength % 2 == 1 && structure.volWidth % 2 == 1) + { + int innerRadius = (Math.min(structure.volLength, structure.volWidth)-3)/2; + + if(innerRadius >= Math.ceil((structure.volHeight-2)/4)) + { + int centerX = structure.minLocation.xCoord+(structure.volLength-1)/2; + int centerZ = structure.minLocation.zCoord+(structure.volWidth-1)/2; + + Coord4D complex = null; + + Set turbines = new HashSet(); + Set dispersers = new HashSet(); + Set coils = new HashSet(); + + //Scan for complex + for(Coord4D coord : innerNodes) + { + TileEntity tile = coord.getTileEntity(pointer.getWorldObj()); + + if(tile instanceof TileEntityRotationalComplex) + { + if(complex != null) + { + return false; + } + else if(coord.xCoord != centerX || coord.zCoord != centerZ) + { + return false; + } + + complex = coord; + } + else if(tile instanceof TileEntityTurbineRotor) + { + if(coord.xCoord != centerX || coord.zCoord != centerZ) + { + return false; + } + + turbines.add(coord); + } + else if(tile instanceof TileEntityPressureDisperser) + { + dispersers.add(coord); + } + else if(tile instanceof TileEntityElectromagneticCoil) + { + coils.add(coord); + } + } + + //Terminate if complex doesn't exist + if(complex == null) + { + return false; + } + + //Make sure a flat, horizontal plane of dispersers exists within the multiblock around the complex + for(int x = complex.xCoord-innerRadius; x <= complex.xCoord+innerRadius; x++) + { + for(int z = complex.zCoord-innerRadius; z <= complex.zCoord+innerRadius; z++) + { + if(!(x == centerX && z == centerZ)) + { + TileEntity tile = pointer.getWorldObj().getTileEntity(x, complex.yCoord, z); + + if(!(tile instanceof TileEntityPressureDisperser)) + { + return false; + } + + dispersers.remove(new Coord4D(x, complex.yCoord, z)); + } + } + } + + //If any dispersers were not processed, they're in the wrong place + if(dispersers.size() > 0) + { + return false; + } + + int turbineHeight = 0; + + //Make sure a complete line of turbine rotors exist from the complex to the multiblock's base + for(int y = complex.yCoord-1; y > structure.minLocation.yCoord; y--) + { + TileEntity tile = pointer.getWorldObj().getTileEntity(centerX, y, centerZ); + + if(!(tile instanceof TileEntityTurbineRotor)) + { + return false; + } + + turbineHeight++; + turbines.remove(new Coord4D(centerX, y, centerZ, pointer.getWorldObj().provider.dimensionId)); + } + + //If any turbines were not processed, they're in the wrong place + if(turbines.size() > 0) + { + return false; + } + + Coord4D startCoord = complex.getFromSide(ForgeDirection.UP); + TileEntity startTile = startCoord.getTileEntity(pointer.getWorldObj()); + + if(startTile instanceof TileEntityElectromagneticCoil) + { + structure.coils = new CoilCounter().calculate((TileEntityElectromagneticCoil)startTile); + } + + Coord4D turbineCoord = complex.getFromSide(ForgeDirection.DOWN); + TileEntity turbineTile = turbineCoord.getTileEntity(pointer.getWorldObj()); + + if(turbineTile instanceof TileEntityTurbineRotor) + { + structure.blades = ((TileEntityTurbineRotor)turbineTile).blades; + } + + if(coils.size() > structure.coils) + { + return false; + } + + for(Coord4D coord : structure.locations) + { + if(coord.getTileEntity(pointer.getWorldObj()) instanceof TileEntityTurbineVent) + { + if(coord.yCoord >= complex.yCoord) + { + structure.vents++; + } + else { + return false; + } + } + } + + structure.lowerVolume = structure.volLength*structure.volWidth*turbineHeight; + + ((TileEntityRotationalComplex)complex.getTileEntity(pointer.getWorldObj())).setMultiblock(structure.inventoryID); + + return true; + } + } + + return false; + } + + @Override + protected MultiblockCache getNewCache() + { + return new TurbineCache(); + } + + @Override + protected SynchronizedTurbineData getNewStructure() + { + return new SynchronizedTurbineData(); + } + + @Override + protected MultiblockManager getManager() + { + return MekanismGenerators.turbineManager; + } + + @Override + protected void mergeCaches(List rejectedItems, MultiblockCache cache, MultiblockCache merge) + { + if(((TurbineCache)cache).fluid == null) + { + ((TurbineCache)cache).fluid = ((TurbineCache)merge).fluid; + } + else if(((TurbineCache)merge).fluid != null && ((TurbineCache)cache).fluid.isFluidEqual(((TurbineCache)merge).fluid)) + { + ((TurbineCache)cache).fluid.amount += ((TurbineCache)merge).fluid.amount; + } + } + + @Override + protected void onFormed() + { + if(structureFound.fluidStored != null) + { + structureFound.fluidStored.amount = Math.min(structureFound.fluidStored.amount, structureFound.getFluidCapacity()); + } + + structureFound.electricityStored = Math.min(structureFound.electricityStored, structureFound.getEnergyCapacity()); + } + + public class CoilCounter + { + public Set iterated = new HashSet(); + + public void loop(Coord4D pos) + { + iterated.add(pos); + + for(ForgeDirection side : ForgeDirection.VALID_DIRECTIONS) + { + Coord4D coord = pos.getFromSide(side); + TileEntity tile = coord.getTileEntity(pointer.getWorldObj()); + + if(!iterated.contains(coord)) + { + if(tile instanceof TileEntityElectromagneticCoil) + { + loop(coord); + } + } + } + } + + public int calculate(TileEntityElectromagneticCoil tileEntity) + { + loop(Coord4D.get(tileEntity)); + + return iterated.size(); + } + } +} diff --git a/src/main/java/mekanism/generators/common/item/ItemBlockGenerator.java b/src/main/java/mekanism/generators/common/item/ItemBlockGenerator.java index f70f958c5..585fddeb2 100644 --- a/src/main/java/mekanism/generators/common/item/ItemBlockGenerator.java +++ b/src/main/java/mekanism/generators/common/item/ItemBlockGenerator.java @@ -46,8 +46,13 @@ import ic2.api.item.ISpecialElectricItem; * 4: Bio-Generator * 5: Advanced Solar Generator * 6: Wind Generator - * 7: Turbine Rod + * 7: Turbine Rotor * 8: Rotational Complex + * 9: Pressure Disperser + * 10: Electromagnetic Coil + * 11: Turbine Casing + * 12: Turbine Valve + * 13: Turbine Vent * @author AidanBrady * */ @@ -65,7 +70,20 @@ public class ItemBlockGenerator extends ItemBlock implements IEnergizedItem, ISp super(block); metaBlock = block; setHasSubtypes(true); - setMaxStackSize(1); + } + + @Override + public int getItemStackLimit(ItemStack stack) + { + GeneratorType type = GeneratorType.getFromMetadata(stack.getItemDamage()); + + if(type.maxEnergy == -1) + { + return 64; + } + else { + return 1; + } } @Override @@ -97,7 +115,7 @@ public class ItemBlockGenerator extends ItemBlock implements IEnergizedItem, ISp { GeneratorType type = GeneratorType.getFromMetadata(itemstack.getItemDamage()); - if(type != GeneratorType.TURBINE_ROD && type != GeneratorType.ROTATIONAL_COMPLEX) + if(type.maxEnergy > -1) { if(!MekKeyHandler.getIsKeyPressed(MekanismKeyHandler.sneakKey)) { diff --git a/src/main/java/mekanism/generators/common/tile/turbine/TileEntityElectromagneticCoil.java b/src/main/java/mekanism/generators/common/tile/turbine/TileEntityElectromagneticCoil.java new file mode 100644 index 000000000..54de2ed9b --- /dev/null +++ b/src/main/java/mekanism/generators/common/tile/turbine/TileEntityElectromagneticCoil.java @@ -0,0 +1,15 @@ +package mekanism.generators.common.tile.turbine; + +import mekanism.common.tile.TileEntityBasicBlock; + +public class TileEntityElectromagneticCoil extends TileEntityBasicBlock +{ + @Override + public boolean canUpdate() + { + return false; + } + + @Override + public void onUpdate() {} +} diff --git a/src/main/java/mekanism/generators/common/tile/turbine/TileEntityPressureDisperser.java b/src/main/java/mekanism/generators/common/tile/turbine/TileEntityPressureDisperser.java new file mode 100644 index 000000000..4f38a86b5 --- /dev/null +++ b/src/main/java/mekanism/generators/common/tile/turbine/TileEntityPressureDisperser.java @@ -0,0 +1,15 @@ +package mekanism.generators.common.tile.turbine; + +import mekanism.common.tile.TileEntityBasicBlock; + +public class TileEntityPressureDisperser extends TileEntityBasicBlock +{ + @Override + public boolean canUpdate() + { + return false; + } + + @Override + public void onUpdate() {} +} diff --git a/src/main/java/mekanism/generators/common/tile/turbine/TileEntityRotationalComplex.java b/src/main/java/mekanism/generators/common/tile/turbine/TileEntityRotationalComplex.java index 9124c4621..2701e6769 100644 --- a/src/main/java/mekanism/generators/common/tile/turbine/TileEntityRotationalComplex.java +++ b/src/main/java/mekanism/generators/common/tile/turbine/TileEntityRotationalComplex.java @@ -88,9 +88,9 @@ public class TileEntityRotationalComplex extends TileEntityBasicBlock Coord4D coord = Coord4D.get(this).getFromSide(EnumFacing.DOWN); TileEntity tile = coord.getTileEntity(worldObj); - if(tile instanceof TileEntityTurbineRod) + if(tile instanceof TileEntityTurbineRotor) { - ((TileEntityTurbineRod)tile).updateRods(); + ((TileEntityTurbineRotor)tile).updateRotors(); } } diff --git a/src/main/java/mekanism/generators/common/tile/turbine/TileEntityTurbineCasing.java b/src/main/java/mekanism/generators/common/tile/turbine/TileEntityTurbineCasing.java new file mode 100644 index 000000000..8f763cbce --- /dev/null +++ b/src/main/java/mekanism/generators/common/tile/turbine/TileEntityTurbineCasing.java @@ -0,0 +1,193 @@ +package mekanism.generators.common.tile.turbine; + +import io.netty.buffer.ByteBuf; + +import java.util.ArrayList; + +import mekanism.api.Coord4D; +import mekanism.api.Range4D; +import mekanism.api.energy.IStrictEnergyStorage; +import mekanism.common.Mekanism; +import mekanism.common.multiblock.MultiblockCache; +import mekanism.common.multiblock.MultiblockManager; +import mekanism.common.multiblock.UpdateProtocol; +import mekanism.common.network.PacketTileEntity.TileEntityMessage; +import mekanism.common.tile.TileEntityMultiblock; +import mekanism.common.util.MekanismUtils; +import mekanism.generators.common.MekanismGenerators; +import mekanism.generators.common.content.turbine.SynchronizedTurbineData; +import mekanism.generators.common.content.turbine.TurbineCache; +import mekanism.generators.common.content.turbine.TurbineUpdateProtocol; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraftforge.fluids.FluidRegistry; +import net.minecraftforge.fluids.FluidStack; + +public class TileEntityTurbineCasing extends TileEntityMultiblock implements IStrictEnergyStorage +{ + public float prevScale; + + public TileEntityTurbineCasing() + { + this("TurbineCasing"); + } + + public TileEntityTurbineCasing(String name) + { + super(name); + } + + @Override + public void onUpdate() + { + super.onUpdate(); + + if(worldObj.isRemote) + { + if(structure != null && clientHasStructure && isRendering) + { + float targetScale = (float)(structure.fluidStored != null ? structure.fluidStored.amount : 0)/structure.getFluidCapacity(); + + if(Math.abs(prevScale - targetScale) > 0.01) + { + prevScale = (9*prevScale + targetScale)/10; + } + } + } + + if(!worldObj.isRemote) + { + if(structure != null) + { + if(structure.fluidStored != null && structure.fluidStored.amount <= 0) + { + structure.fluidStored = null; + markDirty(); + } + + if(isRendering) + { + if(structure.needsRenderUpdate()) + { + sendPacketToRenderer(); + } + + structure.prevFluid = structure.fluidStored; + } + } + } + } + + @Override + public boolean onActivate(EntityPlayer player) + { + if(!player.isSneaking() && structure != null) + { + Mekanism.packetHandler.sendToReceivers(new TileEntityMessage(Coord4D.get(this), getNetworkedData(new ArrayList())), new Range4D(Coord4D.get(this))); + player.openGui(Mekanism.instance, 6, worldObj, xCoord, yCoord, zCoord); + + return true; + } + + return false; + } + + @Override + public double getEnergy() + { + return structure != null ? structure.electricityStored : 0; + } + + @Override + public double getMaxEnergy() + { + return structure.getEnergyCapacity(); + } + + @Override + public void setEnergy(double energy) + { + if(structure != null) + { + structure.electricityStored = Math.max(Math.min(energy, getMaxEnergy()), 0); + MekanismUtils.saveChunk(this); + } + } + + public int getScaledFluidLevel(int i) + { + if(structure.getFluidCapacity() == 0 || structure.fluidStored == null) + { + return 0; + } + + return structure.fluidStored.amount*i / structure.getFluidCapacity(); + } + + @Override + public ArrayList getNetworkedData(ArrayList data) + { + super.getNetworkedData(data); + + if(structure != null) + { + data.add(structure.volume); + data.add(structure.electricityStored); + + if(structure.fluidStored != null) + { + data.add(1); + data.add(structure.fluidStored.getFluidID()); + data.add(structure.fluidStored.amount); + } + else { + data.add(0); + } + } + + return data; + } + + @Override + public void handlePacketData(ByteBuf dataStream) + { + super.handlePacketData(dataStream); + + if(clientHasStructure) + { + structure.volume = dataStream.readInt(); + structure.electricityStored = dataStream.readDouble(); + + if(dataStream.readInt() == 1) + { + structure.fluidStored = new FluidStack(FluidRegistry.getFluid(dataStream.readInt()), dataStream.readInt()); + } + else { + structure.fluidStored = null; + } + } + } + + @Override + protected SynchronizedTurbineData getNewStructure() + { + return new SynchronizedTurbineData(); + } + + @Override + public MultiblockCache getNewCache() + { + return new TurbineCache(); + } + + @Override + protected UpdateProtocol getProtocol() + { + return new TurbineUpdateProtocol(this); + } + + @Override + public MultiblockManager getManager() + { + return MekanismGenerators.turbineManager; + } +} diff --git a/src/main/java/mekanism/generators/common/tile/turbine/TileEntityTurbineRod.java b/src/main/java/mekanism/generators/common/tile/turbine/TileEntityTurbineRotor.java similarity index 69% rename from src/main/java/mekanism/generators/common/tile/turbine/TileEntityTurbineRod.java rename to src/main/java/mekanism/generators/common/tile/turbine/TileEntityTurbineRotor.java index 91238f82a..667e906e6 100644 --- a/src/main/java/mekanism/generators/common/tile/turbine/TileEntityTurbineRod.java +++ b/src/main/java/mekanism/generators/common/tile/turbine/TileEntityTurbineRotor.java @@ -18,9 +18,9 @@ import net.minecraft.util.EnumFacing; import cpw.mods.fml.relauncher.Side; import cpw.mods.fml.relauncher.SideOnly; -public class TileEntityTurbineRod extends TileEntityBasicBlock +public class TileEntityTurbineRotor extends TileEntityBasicBlock { - public List rods = new ArrayList(); + public List rotors = new ArrayList(); public boolean hasComplex; @@ -46,34 +46,34 @@ public class TileEntityTurbineRod extends TileEntityBasicBlock { if(!worldObj.isRemote) { - updateRods(); + updateRotors(); } } - public void updateRods() + public void updateRotors() { - if(rods.contains(Coord4D.get(this))) + if(rotors.contains(Coord4D.get(this))) { - rods.add(Coord4D.get(this)); + rotors.add(Coord4D.get(this)); } - buildRods(); + buildRotors(); Mekanism.packetHandler.sendToReceivers(new TileEntityMessage(Coord4D.get(this), getNetworkedData(new ArrayList())), new Range4D(Coord4D.get(this))); } - private void buildRods() + private void buildRotors() { - List newRods = new ArrayList(); + List newRotors = new ArrayList(); int newBlades = 0; boolean complex = false; String id = null; Coord4D pointer = Coord4D.get(this); - //Go to bottom rod + //Go to bottom rotor while(true) { - if(isRod(pointer.getFromSide(EnumFacing.DOWN))) + if(isRotor(pointer.getFromSide(EnumFacing.DOWN))) { pointer.step(EnumFacing.DOWN); continue; @@ -82,13 +82,13 @@ public class TileEntityTurbineRod extends TileEntityBasicBlock break; } - //Put all rods in new list, top to bottom + //Put all rotors in new list, top to bottom while(true) { - newRods.add(pointer.clone()); - newBlades += ((TileEntityTurbineRod)pointer.getTileEntity(worldObj)).getHousedBlades(); + newRotors.add(pointer.clone()); + newBlades += ((TileEntityTurbineRotor)pointer.getTileEntity(worldObj)).getHousedBlades(); - if(isRod(pointer.getFromSide(EnumFacing.UP))) + if(isRotor(pointer.getFromSide(EnumFacing.UP))) { pointer.step(EnumFacing.UP); continue; @@ -103,42 +103,42 @@ public class TileEntityTurbineRod extends TileEntityBasicBlock complex = true; } - //Update all rods, send packet if necessary - for(Coord4D coord : newRods) + //Update all rotors, send packet if necessary + for(Coord4D coord : newRotors) { - TileEntityTurbineRod rod = (TileEntityTurbineRod)coord.getTileEntity(worldObj); - int prevHoused = rod.getHousedBlades(); - int prevBlades = rod.blades; + TileEntityTurbineRotor rotor = (TileEntityTurbineRotor)coord.getTileEntity(worldObj); + int prevHoused = rotor.getHousedBlades(); + int prevBlades = rotor.blades; - rod.rods = newRods; - rod.blades = newBlades; - rod.multiblockUUID = id; + rotor.rotors = newRotors; + rotor.blades = newBlades; + rotor.multiblockUUID = id; - if(rods.indexOf(coord) == rods.size()-1) + if(rotors.indexOf(coord) == rotors.size()-1) { - rod.hasComplex = complex; + rotor.hasComplex = complex; } else { - rod.hasComplex = false; + rotor.hasComplex = false; } - Mekanism.packetHandler.sendToReceivers(new TileEntityMessage(coord, rod.getNetworkedData(new ArrayList())), new Range4D(coord)); + Mekanism.packetHandler.sendToReceivers(new TileEntityMessage(coord, rotor.getNetworkedData(new ArrayList())), new Range4D(coord)); } } public boolean editBlade(boolean add) { - if(!rods.contains(Coord4D.get(this))) + if(!rotors.contains(Coord4D.get(this))) { - rods.add(Coord4D.get(this)); + rotors.add(Coord4D.get(this)); } - if((add && (rods.size()*2) - blades > 0) || (!add && (blades > 0))) + if((add && (rotors.size()*2) - blades > 0) || (!add && (blades > 0))) { - for(Coord4D coord : rods) + for(Coord4D coord : rotors) { - TileEntityTurbineRod rod = (TileEntityTurbineRod)coord.getTileEntity(worldObj); - rod.internalEditBlade(add); + TileEntityTurbineRotor rotor = (TileEntityTurbineRotor)coord.getTileEntity(worldObj); + rotor.internalEditBlade(add); } return true; @@ -164,9 +164,9 @@ public class TileEntityTurbineRod extends TileEntityBasicBlock { if(!worldObj.isRemote) { - if(rods.size() > 0) + if(rotors.size() > 0) { - return Math.max(0, Math.min(2, blades - (rods.indexOf(Coord4D.get(this)))*2)); + return Math.max(0, Math.min(2, blades - (rotors.indexOf(Coord4D.get(this)))*2)); } else { return blades; @@ -177,9 +177,9 @@ public class TileEntityTurbineRod extends TileEntityBasicBlock } } - private boolean isRod(Coord4D coord) + private boolean isRotor(Coord4D coord) { - return coord.getTileEntity(worldObj) instanceof TileEntityTurbineRod; + return coord.getTileEntity(worldObj) instanceof TileEntityTurbineRotor; } private boolean isComplex(Coord4D coord) @@ -194,7 +194,7 @@ public class TileEntityTurbineRod extends TileEntityBasicBlock if(!worldObj.isRemote) { - updateRods(); + updateRotors(); } } @@ -230,7 +230,7 @@ public class TileEntityTurbineRod extends TileEntityBasicBlock super.getNetworkedData(data); data.add(getHousedBlades()); - data.add(rods.indexOf(Coord4D.get(this))); + data.add(rotors.indexOf(Coord4D.get(this))); if(multiblockUUID != null) { diff --git a/src/main/java/mekanism/generators/common/tile/turbine/TileEntityTurbineValve.java b/src/main/java/mekanism/generators/common/tile/turbine/TileEntityTurbineValve.java new file mode 100644 index 000000000..dc6f958da --- /dev/null +++ b/src/main/java/mekanism/generators/common/tile/turbine/TileEntityTurbineValve.java @@ -0,0 +1,412 @@ +package mekanism.generators.common.tile.turbine; + +import ic2.api.energy.EnergyNet; +import ic2.api.energy.event.EnergyTileLoadEvent; +import ic2.api.energy.event.EnergyTileUnloadEvent; +import ic2.api.energy.tile.IEnergyConductor; +import ic2.api.energy.tile.IEnergyTile; + +import java.util.EnumSet; + +import mekanism.api.Coord4D; +import mekanism.api.MekanismConfig.general; +import mekanism.api.transmitters.ITransmitterTile; +import mekanism.common.base.IEnergyWrapper; +import mekanism.common.util.CableUtils; +import mekanism.common.util.LangUtils; +import mekanism.common.util.MekanismUtils; +import mekanism.common.util.PipeUtils; +import mekanism.generators.common.content.turbine.TurbineFluidTank; +import net.minecraft.tileentity.TileEntity; +import net.minecraftforge.common.MinecraftForge; +import net.minecraftforge.common.util.ForgeDirection; +import net.minecraftforge.fluids.Fluid; +import net.minecraftforge.fluids.FluidRegistry; +import net.minecraftforge.fluids.FluidStack; +import net.minecraftforge.fluids.FluidTankInfo; +import net.minecraftforge.fluids.IFluidHandler; +import cpw.mods.fml.common.Optional.Interface; +import cpw.mods.fml.common.Optional.InterfaceList; +import cpw.mods.fml.common.Optional.Method; + +@InterfaceList({ + @Interface(iface = "ic2.api.energy.tile.IEnergySink", modid = "IC2"), + @Interface(iface = "ic2.api.energy.tile.IEnergySource", modid = "IC2"), + @Interface(iface = "ic2.api.tile.IEnergyStorage", modid = "IC2"), + @Interface(iface = "cofh.api.energy.IEnergyHandler", modid = "CoFHCore"), +}) +public class TileEntityTurbineValve extends TileEntityTurbineCasing implements IFluidHandler, IEnergyWrapper +{ + public boolean ic2Registered = false; + + public TurbineFluidTank fluidTank; + + public TileEntityTurbineValve() + { + super("TurbineValve"); + fluidTank = new TurbineFluidTank(this); + } + + @Override + public void onUpdate() + { + super.onUpdate(); + + if(!ic2Registered && MekanismUtils.useIC2()) + { + register(); + } + + if(!worldObj.isRemote) + { + if(structure != null) + { + double prev = getEnergy(); + CableUtils.emit(this); + } + } + } + + @Override + public EnumSet getOutputtingSides() + { + if(structure != null) + { + EnumSet set = EnumSet.allOf(ForgeDirection.class); + set.remove(ForgeDirection.UNKNOWN); + + for(ForgeDirection side : ForgeDirection.VALID_DIRECTIONS) + { + if(structure.locations.contains(Coord4D.get(this).getFromSide(side))) + { + set.remove(side); + } + } + + return set; + } + + return EnumSet.noneOf(ForgeDirection.class); + } + + @Override + public EnumSet getConsumingSides() + { + return EnumSet.noneOf(ForgeDirection.class); + } + + @Override + public boolean canUpdate() + { + return true; + } + + @Method(modid = "IC2") + public void register() + { + if(!worldObj.isRemote) + { + TileEntity registered = EnergyNet.instance.getTileEntity(worldObj, xCoord, yCoord, zCoord); + + if(registered != this) + { + if(registered instanceof IEnergyTile) + { + MinecraftForge.EVENT_BUS.post(new EnergyTileUnloadEvent((IEnergyTile)registered)); + } + else if(registered == null) + { + MinecraftForge.EVENT_BUS.post(new EnergyTileLoadEvent(this)); + ic2Registered = true; + } + } + } + } + + @Method(modid = "IC2") + public void deregister() + { + if(!worldObj.isRemote) + { + TileEntity registered = EnergyNet.instance.getTileEntity(worldObj, xCoord, yCoord, zCoord); + + if(registered instanceof IEnergyTile) + { + MinecraftForge.EVENT_BUS.post(new EnergyTileUnloadEvent((IEnergyTile)registered)); + } + } + } + + @Override + public double getMaxOutput() + { + return structure != null ? structure.getEnergyCapacity() : 0; + } + + @Override + public void onAdded() + { + super.onAdded(); + + if(MekanismUtils.useIC2()) + { + register(); + } + } + + @Override + public void onChunkUnload() + { + if(MekanismUtils.useIC2()) + { + deregister(); + } + + super.onChunkUnload(); + } + + @Override + public void invalidate() + { + super.invalidate(); + + if(MekanismUtils.useIC2()) + { + deregister(); + } + } + + @Override + @Method(modid = "CoFHCore") + public int receiveEnergy(ForgeDirection from, int maxReceive, boolean simulate) + { + return 0; + } + + @Override + @Method(modid = "CoFHCore") + public int extractEnergy(ForgeDirection from, int maxExtract, boolean simulate) + { + if(getOutputtingSides().contains(from)) + { + double toSend = Math.min(getEnergy(), Math.min(getMaxOutput(), maxExtract*general.FROM_TE)); + + if(!simulate) + { + setEnergy(getEnergy() - toSend); + } + + return (int)Math.round(toSend*general.TO_TE); + } + + return 0; + } + + @Override + @Method(modid = "CoFHCore") + public boolean canConnectEnergy(ForgeDirection from) + { + return structure != null; + } + + @Override + @Method(modid = "CoFHCore") + public int getEnergyStored(ForgeDirection from) + { + return (int)Math.round(getEnergy()*general.TO_TE); + } + + @Override + @Method(modid = "CoFHCore") + public int getMaxEnergyStored(ForgeDirection from) + { + return (int)Math.round(getMaxEnergy()*general.TO_TE); + } + + @Override + @Method(modid = "IC2") + public int getSinkTier() + { + return 4; + } + + @Override + @Method(modid = "IC2") + public int getSourceTier() + { + return 4; + } + + @Override + @Method(modid = "IC2") + public void setStored(int energy) + { + setEnergy(energy*general.FROM_IC2); + } + + @Override + @Method(modid = "IC2") + public int addEnergy(int amount) + { + return (int)Math.round(getEnergy()*general.TO_IC2); + } + + @Override + @Method(modid = "IC2") + public boolean isTeleporterCompatible(ForgeDirection side) + { + return canOutputTo(side); + } + + @Override + public boolean canOutputTo(ForgeDirection side) + { + return getOutputtingSides().contains(side); + } + + @Override + @Method(modid = "IC2") + public boolean acceptsEnergyFrom(TileEntity emitter, ForgeDirection direction) + { + return false; + } + + @Override + @Method(modid = "IC2") + public boolean emitsEnergyTo(TileEntity receiver, ForgeDirection direction) + { + return getOutputtingSides().contains(direction) && receiver instanceof IEnergyConductor; + } + + @Override + @Method(modid = "IC2") + public int getStored() + { + return (int)Math.round(getEnergy()*general.TO_IC2); + } + + @Override + @Method(modid = "IC2") + public int getCapacity() + { + return (int)Math.round(getMaxEnergy()*general.TO_IC2); + } + + @Override + @Method(modid = "IC2") + public int getOutput() + { + return (int)Math.round(getMaxOutput()*general.TO_IC2); + } + + @Override + @Method(modid = "IC2") + public double getDemandedEnergy() + { + return 0; + } + + @Override + @Method(modid = "IC2") + public double getOfferedEnergy() + { + return Math.min(getEnergy(), getMaxOutput())*general.TO_IC2; + } + + @Override + public boolean canReceiveEnergy(ForgeDirection side) + { + return false; + } + + @Override + @Method(modid = "IC2") + public double getOutputEnergyUnitsPerTick() + { + return getMaxOutput()*general.TO_IC2; + } + + @Override + @Method(modid = "IC2") + public double injectEnergy(ForgeDirection direction, double amount, double voltage) + { + return amount; + } + + @Override + @Method(modid = "IC2") + public void drawEnergy(double amount) + { + if(structure != null) + { + double toDraw = Math.min(amount*general.FROM_IC2, getMaxOutput()); + setEnergy(Math.max(getEnergy() - toDraw, 0)); + } + } + + @Override + public double transferEnergyToAcceptor(ForgeDirection side, double amount) + { + return 0; + } + + @Override + public FluidTankInfo[] getTankInfo(ForgeDirection from) + { + return ((!worldObj.isRemote && structure != null) || (worldObj.isRemote && clientHasStructure)) ? new FluidTankInfo[] {fluidTank.getInfo()} : PipeUtils.EMPTY; + } + + @Override + public int fill(ForgeDirection from, FluidStack resource, boolean doFill) + { + return fluidTank.fill(resource, doFill); + } + + @Override + public FluidStack drain(ForgeDirection from, FluidStack resource, boolean doDrain) + { + if(structure != null && structure.fluidStored != null) + { + if(resource.getFluid() == structure.fluidStored.getFluid()) + { + return fluidTank.drain(resource.amount, doDrain); + } + } + + return null; + } + + @Override + public FluidStack drain(ForgeDirection from, int maxDrain, boolean doDrain) + { + if(structure != null) + { + return fluidTank.drain(maxDrain, doDrain); + } + + return null; + } + + @Override + public boolean canFill(ForgeDirection from, Fluid fluid) + { + if(fluid == FluidRegistry.getFluid("steam")) + { + return ((!worldObj.isRemote && structure != null) || (worldObj.isRemote && clientHasStructure)); + } + + return false; + } + + @Override + public boolean canDrain(ForgeDirection from, Fluid fluid) + { + return ((!worldObj.isRemote && structure != null) || (worldObj.isRemote && clientHasStructure)); + } + + @Override + public String getInventoryName() + { + return LangUtils.localize("gui.industrialTurbine"); + } +} diff --git a/src/main/java/mekanism/generators/common/tile/turbine/TileEntityTurbineVent.java b/src/main/java/mekanism/generators/common/tile/turbine/TileEntityTurbineVent.java new file mode 100644 index 000000000..c7d6d2f61 --- /dev/null +++ b/src/main/java/mekanism/generators/common/tile/turbine/TileEntityTurbineVent.java @@ -0,0 +1,9 @@ +package mekanism.generators.common.tile.turbine; + +public class TileEntityTurbineVent extends TileEntityTurbineCasing +{ + public TileEntityTurbineVent() + { + super("TurbineVent"); + } +} diff --git a/src/main/resources/assets/mekanism/lang/en_US.lang b/src/main/resources/assets/mekanism/lang/en_US.lang index 698be237c..5365c1287 100644 --- a/src/main/resources/assets/mekanism/lang/en_US.lang +++ b/src/main/resources/assets/mekanism/lang/en_US.lang @@ -77,7 +77,7 @@ tile.BasicBlock.Bin.name=Bin tile.BasicBlock.TeleporterFrame.name=Teleporter Frame tile.BasicBlock.SteelCasing.name=Steel Casing tile.BasicBlock.DynamicTank.name=Dynamic Tank -tile.BasicBlock.DynamicGlass.name=Dynamic Glass +tile.BasicBlock.StructuralGlass.name=Structural Glass tile.BasicBlock.DynamicValve.name=Dynamic Valve tile.BasicBlock.CopperBlock.name=Copper Block tile.BasicBlock.TinBlock.name=Tin Block @@ -312,6 +312,7 @@ fluid.lithium=Liquid Lithium fluid.deuterium=Liquid Deuterium fluid.tritium=Liquid Tritium fluid.fusionFuelDT=Liquid D-T Fuel +fluid.steam=Steam //OreGas names oregas.iron=Iron Ore @@ -448,6 +449,7 @@ gui.cells=cells gui.providers=providers gui.structure=Structure gui.dynamicTank=Dynamic Tank +gui.industrialTurbine=Industrial Turbine gui.visuals=Visuals gui.noEject=Can't Eject gui.undefined=Undefined @@ -735,8 +737,13 @@ tooltip.GasGenerator=A generator that harnesses the molecular !nvarying gasses t tooltip.BioGenerator=A generator that burns organic materials of !nthe world to produce energy. tooltip.AdvancedSolarGenerator=An advanced generator that directly !nabsorbs the sun's rays with little loss !nto produce energy. tooltip.WindGenerator=A generator that uses the strength of the wind !nto produce energy, with greater efficiency !nat higher levels. -tooltip.TurbineRod=The steel rod that is used to house !nTurbine Blades within an Industrial Turbine. -tooltip.RotationalComplex=A connector that is placed on !nthe highest turbine rod to carry kinetic energy into the !ngenerator itself. +tooltip.TurbineRotor=The steel rod that is used to house !nTurbine Blades within an Industrial Turbine. +tooltip.RotationalComplex=A connector that is placed on the highest !nTurbine Rotor of an Industrial Turbine to !ncarry kinetic energy into its !nElectromagnetic Coils. +tooltip.PressureDisperser=A block used in the Industrial Turbine!n to direct steam outwards. These should !nbe placed just above your turbine rods, forming a !ngapless layer of dispersers surrounding your !nRotational Complex. +tooltip.ElectromagneticCoil=A block that converts kinetic energy from a !nRotational Complex into useable electricity. These can be placed in !nany arrangement above your Rotational Complex, as long !nas they are all touching each other and the !ncomplex itself. +tooltip.TurbineCasing=Pressure-resistant casing used in the !ncreation of an Industrial Turbine. +tooltip.TurbineValve=A type of Turbine Casing that includes a !nport for the transfer of energy and steam. +tooltip.TurbineVent=A type of Turbine Casing with an integrated !nvent for the release of steam. These !nshould be placed on the level of or above the turbine's !nRotational Complex. tooltip.ReactorGlass=Reinforced glass that can be used in !nthe Fusion Reactor multiblock. tooltip.ReactorLaserFocusMatrix=A panel of Reactor Glass that !nis capable of absorbing optical energy and !nthereby heating up the Fusion Reactor. @@ -848,8 +855,13 @@ tile.Generator.GasGenerator.name=Gas-Burning Generator tile.Generator.BioGenerator.name=Bio-Generator tile.Generator.AdvancedSolarGenerator.name=Advanced Solar Generator tile.Generator.WindGenerator.name=Wind Generator -tile.Generator.TurbineRod.name=Turbine Rod +tile.Generator.TurbineRotor.name=Turbine Rotor tile.Generator.RotationalComplex.name=Rotational Complex +tile.Generator.PressureDisperser.name=Pressure Disperser +tile.Generator.ElectromagneticCoil.name=Electromagnetic Coil +tile.Generator.TurbineCasing.name=Turbine Casing +tile.Generator.TurbineValve.name=Turbine Valve +tile.Generator.TurbineVent.name=Turbine Vent tile.Reactor.ReactorController.name=Reactor Controller tile.Reactor.ReactorFrame.name=Reactor Frame diff --git a/src/main/resources/assets/mekanism/textures/blocks/PressureDisperser.png b/src/main/resources/assets/mekanism/textures/blocks/PressureDisperser.png new file mode 100644 index 000000000..52cbb4190 Binary files /dev/null and b/src/main/resources/assets/mekanism/textures/blocks/PressureDisperser.png differ diff --git a/src/main/resources/assets/mekanism/textures/blocks/RotationalComplexSide.png b/src/main/resources/assets/mekanism/textures/blocks/RotationalComplexSide.png new file mode 100644 index 000000000..61b18bac1 Binary files /dev/null and b/src/main/resources/assets/mekanism/textures/blocks/RotationalComplexSide.png differ diff --git a/src/main/resources/assets/mekanism/textures/blocks/RotationalComplexTop.png b/src/main/resources/assets/mekanism/textures/blocks/RotationalComplexTop.png new file mode 100644 index 000000000..5b0da1193 Binary files /dev/null and b/src/main/resources/assets/mekanism/textures/blocks/RotationalComplexTop.png differ diff --git a/src/main/resources/assets/mekanism/textures/blocks/ctm/ElectromagneticCoil-ctm.png b/src/main/resources/assets/mekanism/textures/blocks/ctm/ElectromagneticCoil-ctm.png new file mode 100644 index 000000000..47ce61b38 Binary files /dev/null and b/src/main/resources/assets/mekanism/textures/blocks/ctm/ElectromagneticCoil-ctm.png differ diff --git a/src/main/resources/assets/mekanism/textures/blocks/ctm/ElectromagneticCoil.png b/src/main/resources/assets/mekanism/textures/blocks/ctm/ElectromagneticCoil.png new file mode 100644 index 000000000..891d9d03d Binary files /dev/null and b/src/main/resources/assets/mekanism/textures/blocks/ctm/ElectromagneticCoil.png differ diff --git a/src/main/resources/assets/mekanism/textures/blocks/ctm/TurbineCasing-ctm.png b/src/main/resources/assets/mekanism/textures/blocks/ctm/TurbineCasing-ctm.png new file mode 100644 index 000000000..58a8410be Binary files /dev/null and b/src/main/resources/assets/mekanism/textures/blocks/ctm/TurbineCasing-ctm.png differ diff --git a/src/main/resources/assets/mekanism/textures/blocks/ctm/TurbineCasing.png b/src/main/resources/assets/mekanism/textures/blocks/ctm/TurbineCasing.png new file mode 100644 index 000000000..be7474646 Binary files /dev/null and b/src/main/resources/assets/mekanism/textures/blocks/ctm/TurbineCasing.png differ diff --git a/src/main/resources/assets/mekanism/textures/blocks/ctm/TurbineValve-ctm.png b/src/main/resources/assets/mekanism/textures/blocks/ctm/TurbineValve-ctm.png new file mode 100644 index 000000000..53999ae47 Binary files /dev/null and b/src/main/resources/assets/mekanism/textures/blocks/ctm/TurbineValve-ctm.png differ diff --git a/src/main/resources/assets/mekanism/textures/blocks/ctm/TurbineValve.png b/src/main/resources/assets/mekanism/textures/blocks/ctm/TurbineValve.png new file mode 100644 index 000000000..f7f956737 Binary files /dev/null and b/src/main/resources/assets/mekanism/textures/blocks/ctm/TurbineValve.png differ diff --git a/src/main/resources/assets/mekanism/textures/blocks/ctm/TurbineVent-ctm.png b/src/main/resources/assets/mekanism/textures/blocks/ctm/TurbineVent-ctm.png new file mode 100644 index 000000000..358dee714 Binary files /dev/null and b/src/main/resources/assets/mekanism/textures/blocks/ctm/TurbineVent-ctm.png differ diff --git a/src/main/resources/assets/mekanism/textures/blocks/ctm/TurbineVent.png b/src/main/resources/assets/mekanism/textures/blocks/ctm/TurbineVent.png new file mode 100644 index 000000000..e522259ef Binary files /dev/null and b/src/main/resources/assets/mekanism/textures/blocks/ctm/TurbineVent.png differ