Merge branch 'v9' into 1.8.9

This commit is contained in:
Ben Spiers committed 2016-01-23 13:50:43 +00:00
commit 0f40514cc7
57 files changed
+2145 -294

No files matched your search

@@ -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
@@ -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);
@@ -15,7 +15,6 @@ import net.minecraft.util.IIcon;
*/
public class RenderBlocksCTM extends RenderBlocks
{
RenderBlocksCTM()
{
super();
@@ -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) {}
@@ -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<SynchronizedTankData> tankManager = new MultiblockManager<SynchronizedTankData>("dynamicTank");
public static MultiblockManager<SynchronizedMatrixData> matrixManager = new MultiblockManager<SynchronizedMatrixData>("inductionMatrix");
public static MultiblockManager<SynchronizedTurbineData> turbineManager = new MultiblockManager<SynchronizedTurbineData>("industrialTurbine");
public static MultiblockManager<SynchronizedBoilerData> boilerManager = new BoilerManager("thermoelectricBoiler");
/** FrequencyManagers for various networks */
@@ -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);
}
@@ -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
{
@@ -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;
}
}
@@ -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)
{
@@ -1,8 +0,0 @@
package mekanism.common.content.turbine;
import mekanism.common.multiblock.SynchronizedData;
public class SynchronizedTurbineData extends SynchronizedData<SynchronizedTurbineData>
{
}
@@ -1,32 +0,0 @@
package mekanism.common.content.turbine;
import mekanism.common.multiblock.MultiblockCache;
import net.minecraft.nbt.NBTTagCompound;
public class TurbineCache extends MultiblockCache<SynchronizedTurbineData>
{
@Override
public void apply(SynchronizedTurbineData data)
{
}
@Override
public void sync(SynchronizedTurbineData data)
{
}
@Override
public void load(NBTTagCompound nbtTags)
{
}
@Override
public void save(NBTTagCompound nbtTags)
{
}
}
@@ -1,6 +0,0 @@
package mekanism.common.content.turbine;
public class TurbineUpdateProtocol
{
}
@@ -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";
@@ -1,6 +1,12 @@
package mekanism.common.multiblock;
import net.minecraft.entity.player.EntityPlayer;
public interface IMultiblock<T extends SynchronizedData<T>>
{
public T getSynchronizedData();
public boolean onActivate(EntityPlayer player);
public void update();
}
@@ -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();
}
@@ -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<T extends SynchronizedData<T>>
{
/** The multiblock nodes that have already been iterated over. */
public Set<TileEntityMultiblock<T>> iteratedNodes = new HashSet<TileEntityMultiblock<T>>();
public Set<TileEntity> iteratedNodes = new HashSet<TileEntity>();
public Set<Coord4D> innerNodes = new HashSet<Coord4D>();
@@ -34,7 +35,7 @@ public abstract class UpdateProtocol<T extends SynchronizedData<T>>
* Recursively loops through each node connected to the given TileEntity.
* @param tile - the TileEntity to loop over
*/
public void loopThrough(TileEntityMultiblock<T> tile)
public void loopThrough(TileEntity tile)
{
World worldObj = tile.getWorldObj();
@@ -157,7 +158,10 @@ public abstract class UpdateProtocol<T extends SynchronizedData<T>>
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<T extends SynchronizedData<T>>
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<T extends SynchronizedData<T>>
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<T>)tileEntity);
loopThrough(tileEntity);
}
}
}
}
public boolean isInteriorValid(T structure)
protected boolean canForm(T structure)
{
return true;
}
@@ -289,6 +294,14 @@ public abstract class UpdateProtocol<T extends SynchronizedData<T>>
{
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<T extends SynchronizedData<T>>
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<T extends SynchronizedData<T>>
if(structureFound != null)
{
for(TileEntityMultiblock<T> tileEntity : iteratedNodes)
for(TileEntity tileEntity : iteratedNodes)
{
if(!structureFound.locations.contains(Coord4D.get(tileEntity)))
{
for(TileEntity tile : iteratedNodes)
{
((TileEntityMultiblock<T>)tile).structure = null;
if(tile instanceof TileEntityMultiblock)
{
((TileEntityMultiblock<T>)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<T extends SynchronizedData<T>>
for(Coord4D obj : structureFound.locations)
{
TileEntityMultiblock<T> tileEntity = (TileEntityMultiblock<T>)obj.getTileEntity(pointer.getWorldObj());
TileEntity tileEntity = obj.getTileEntity(pointer.getWorldObj());
if(tileEntity.cachedID != null)
if(tileEntity instanceof TileEntityMultiblock && ((TileEntityMultiblock<T>)tileEntity).cachedID != null)
{
idsFound.add(tileEntity.cachedID);
idsFound.add(((TileEntityMultiblock<T>)tileEntity).cachedID);
}
}
@@ -451,24 +478,60 @@ public abstract class UpdateProtocol<T extends SynchronizedData<T>>
onFormed();
structureFound.inventoryID = idToUse;
List<IStructuralMultiblock> structures = new ArrayList<IStructuralMultiblock>();
Coord4D toUse = null;
for(Coord4D obj : structureFound.locations)
{
TileEntityMultiblock<T> tileEntity = (TileEntityMultiblock<T>)obj.getTileEntity(pointer.getWorldObj());
TileEntity tileEntity = obj.getTileEntity(pointer.getWorldObj());
tileEntity.structure = (T)structureFound;
if(tileEntity instanceof TileEntityMultiblock)
{
((TileEntityMultiblock<T>)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<T> 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<T> tileEntity = (TileEntityMultiblock<T>)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);
}
}
}
@@ -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<SynchronizedTank
}
}
@Override
public boolean onActivate(EntityPlayer player)
{
if(!player.isSneaking() && structure != null)
{
if(!BlockBasic.manageInventory(player, this))
{
Mekanism.packetHandler.sendToReceivers(new TileEntityMessage(Coord4D.get(this), getNetworkedData(new ArrayList())), new Range4D(Coord4D.get(this)));
player.openGui(Mekanism.instance, 18, worldObj, xCoord, yCoord, zCoord);
}
else {
player.inventory.markDirty();
sendPacketToRenderer();
}
return true;
}
return false;
}
@Override
protected SynchronizedTankData getNewStructure()
{
@@ -361,7 +385,7 @@ public class TileEntityDynamicTank extends TileEntityMultiblock<SynchronizedTank
if(dataStream.readInt() == 1)
{
structure.fluidStored = new FluidStack(dataStream.readInt(), dataStream.readInt());
structure.fluidStored = new FluidStack(FluidRegistry.getFluid(dataStream.readInt()), dataStream.readInt());
}
else {
structure.fluidStored = null;
@@ -1,6 +1,11 @@
package mekanism.common.tile;
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.content.matrix.MatrixCache;
@@ -8,13 +13,13 @@ import mekanism.common.content.matrix.MatrixUpdateProtocol;
import mekanism.common.content.matrix.SynchronizedMatrixData;
import mekanism.common.integration.IComputerIntegration;
import mekanism.common.multiblock.MultiblockManager;
import mekanism.common.network.PacketTileEntity.TileEntityMessage;
import mekanism.common.util.ChargeUtils;
import mekanism.common.util.LangUtils;
import mekanism.common.util.MekanismUtils;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.item.ItemStack;
import java.util.ArrayList;
public class TileEntityInductionCasing extends TileEntityMultiblock<SynchronizedMatrixData> implements IStrictEnergyStorage, IComputerIntegration
{
public int clientCells;
@@ -52,6 +57,20 @@ public class TileEntityInductionCasing extends TileEntityMultiblock<Synchronized
}
}
@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, 49, worldObj, xCoord, yCoord, zCoord);
return true;
}
return false;
}
@Override
public ArrayList getNetworkedData(ArrayList data)
{
@@ -107,12 +107,6 @@ public class TileEntityInductionPort extends TileEntityInductionCasing implement
return EnumSet.noneOf(EnumFacing.class);
}
@Override
public boolean canUpdate()
{
return true;
}
@Method(modid = "IC2")
public void register()
{
@@ -8,6 +8,7 @@ import mekanism.api.Coord4D;
import mekanism.api.Range4D;
import mekanism.common.Mekanism;
import mekanism.common.multiblock.IMultiblock;
import mekanism.common.multiblock.IStructuralMultiblock;
import mekanism.common.multiblock.MultiblockCache;
import mekanism.common.multiblock.MultiblockManager;
import mekanism.common.multiblock.SynchronizedData;
@@ -133,6 +134,7 @@ public abstract class TileEntityMultiblock<T extends SynchronizedData<T>> extend
}
}
@Override
public void update()
{
if(!worldObj.isRemote && (structure == null || !getSynchronizedData().didTick))
@@ -273,6 +275,12 @@ public abstract class TileEntityMultiblock<T extends SynchronizedData<T>> extend
}
}
@Override
public boolean onActivate(EntityPlayer player)
{
return false;
}
@Override
@SideOnly(Side.CLIENT)
public AxisAlignedBB getRenderBoundingBox()
@@ -758,10 +758,7 @@ public class TileEntitySolarEvaporationController extends TileEntitySolarEvapora
}
@Override
public void setActive(boolean active)
{
}
public void setActive(boolean active) {}
@Override
public boolean renderUpdate()
@@ -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<Coord4D> iterated = new HashSet<Coord4D>();
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;
}
}
}
@@ -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;
}
@@ -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();
}
}
@@ -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;
}
}
@@ -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<RenderData, DisplayInteger[]> cachedFluids = new HashMap<RenderData, DisplayInteger[]>();
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();
}
}
@@ -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();
@@ -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);
}
}
}
@@ -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:
@@ -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()
{
@@ -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<SynchronizedTurbineData> turbineManager = new MultiblockManager<SynchronizedTurbineData>("industrialTurbine");
@EventHandler
public void preInit(FMLPreInitializationEvent event)
@@ -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);
}
@@ -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)
@@ -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<SynchronizedTurbineData>
{
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;
}
}
@@ -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<SynchronizedTurbineData>
{
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);
}
}
@@ -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);
}
}
@@ -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<SynchronizedTurbineData>
{
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<Coord4D> turbines = new HashSet<Coord4D>();
Set<Coord4D> dispersers = new HashSet<Coord4D>();
Set<Coord4D> coils = new HashSet<Coord4D>();
//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<SynchronizedTurbineData> getNewCache()
{
return new TurbineCache();
}
@Override
protected SynchronizedTurbineData getNewStructure()
{
return new SynchronizedTurbineData();
}
@Override
protected MultiblockManager<SynchronizedTurbineData> getManager()
{
return MekanismGenerators.turbineManager;
}
@Override
protected void mergeCaches(List<ItemStack> rejectedItems, MultiblockCache<SynchronizedTurbineData> cache, MultiblockCache<SynchronizedTurbineData> 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<Coord4D> iterated = new HashSet<Coord4D>();
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();
}
}
}
@@ -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))
{
@@ -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() {}
}
@@ -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() {}
}
@@ -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();
}
}
@@ -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<SynchronizedTurbineData> 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<SynchronizedTurbineData> getNewCache()
{
return new TurbineCache();
}
@Override
protected UpdateProtocol<SynchronizedTurbineData> getProtocol()
{
return new TurbineUpdateProtocol(this);
}
@Override
public MultiblockManager<SynchronizedTurbineData> getManager()
{
return MekanismGenerators.turbineManager;
}
}
@@ -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<Coord4D> rods = new ArrayList<Coord4D>();
public List<Coord4D> rotors = new ArrayList<Coord4D>();
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<Coord4D> newRods = new ArrayList<Coord4D>();
List<Coord4D> newRotors = new ArrayList<Coord4D>();
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)
{
@@ -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<ForgeDirection> 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<ForgeDirection> 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");
}
}
@@ -0,0 +1,9 @@
package mekanism.generators.common.tile.turbine;
public class TileEntityTurbineVent extends TileEntityTurbineCasing
{
public TileEntityTurbineVent()
{
super("TurbineVent");
}
}