Applied-Energistics-2-tiler.../tile/qnb/TileQuantumBridge.java
2014-07-23 13:55:20 -05:00

292 lines
6 KiB
Java

package appeng.tile.qnb;
import io.netty.buffer.ByteBuf;
import java.io.IOException;
import java.util.EnumSet;
import net.minecraft.inventory.IInventory;
import net.minecraft.item.ItemStack;
import net.minecraft.nbt.NBTTagCompound;
import net.minecraft.tileentity.TileEntity;
import net.minecraftforge.common.util.ForgeDirection;
import appeng.api.AEApi;
import appeng.api.networking.GridFlags;
import appeng.api.networking.events.MENetworkEventSubscribe;
import appeng.api.networking.events.MENetworkPowerStatusChange;
import appeng.api.util.AECableType;
import appeng.api.util.DimensionalCoord;
import appeng.me.GridAccessException;
import appeng.me.cluster.IAECluster;
import appeng.me.cluster.IAEMultiBlock;
import appeng.me.cluster.implementations.QuantumCalculator;
import appeng.me.cluster.implementations.QuantumCluster;
import appeng.tile.events.AETileEventHandler;
import appeng.tile.events.TileEventType;
import appeng.tile.grid.AENetworkInvTile;
import appeng.tile.inventory.AppEngInternalInventory;
import appeng.tile.inventory.InvOperation;
import appeng.util.Platform;
public class TileQuantumBridge extends AENetworkInvTile implements IAEMultiBlock
{
final private static ItemStack ring = AEApi.instance().blocks().blockQuantumRing.stack( 1 );
final int sidesRing[] = new int[] {};
final int sidesLink[] = new int[] { 0 };
AppEngInternalInventory inv = new AppEngInternalInventory( this, 1 );
public final byte corner = 16;
final byte hasSingularity = 32;
final byte powered = 64;
private QuantumCalculator calc = new QuantumCalculator( this );
byte xdex = -1;
QuantumCluster clust;
public boolean bridgePowered;
private boolean updateStatus = false;
class QBridgeHandler extends AETileEventHandler
{
public QBridgeHandler() {
super( TileEventType.NETWORK, TileEventType.TICK );
gridProxy.setValidSides( EnumSet.noneOf( ForgeDirection.class ) );
gridProxy.setFlags( GridFlags.DENSE_CAPACITY );
gridProxy.setIdlePowerUsage( 22 );
inv.setMaxStackSize( 1 );
}
@Override
public void Tick()
{
if ( updateStatus )
{
updateStatus = false;
if ( clust != null )
clust.updateStatus( true );
markForUpdate();
}
}
@Override
public void writeToStream(ByteBuf data) throws IOException
{
int out = xdex;
if ( getStackInSlot( 0 ) != null && xdex != -1 )
out = out | hasSingularity;
if ( gridProxy.isActive() && xdex != -1 )
out = out | powered;
data.writeByte( (byte) out );
}
@Override
public boolean readFromStream(ByteBuf data) throws IOException
{
int oldValue = xdex;
xdex = data.readByte();
bridgePowered = (xdex | powered) == powered;
return xdex != oldValue;
}
};
public TileQuantumBridge() {
addNewHandler( new QBridgeHandler() );
gridProxy.setFlags( GridFlags.DENSE_CAPACITY );
}
public IInventory getInternalInventory()
{
return inv;
}
@MENetworkEventSubscribe
public void PowerSwitch(MENetworkPowerStatusChange c)
{
updateStatus = true;
}
@Override
public void onChangeInventory(IInventory inv, int slot, InvOperation mc, ItemStack removed, ItemStack added)
{
if ( clust != null )
clust.updateStatus( true );
}
@Override
public int[] getAccessibleSlotsBySide(ForgeDirection side)
{
if ( isCenter() )
return sidesLink;
return sidesRing;
}
@Override
public void disconnect(boolean affectWorld)
{
if ( clust != null )
{
if ( !affectWorld )
clust.updateStatus = false;
clust.destroy();
}
clust = null;
if ( affectWorld )
gridProxy.setValidSides( EnumSet.noneOf( ForgeDirection.class ) );
}
@Override
public IAECluster getCluster()
{
return clust;
}
@Override
public boolean isValid()
{
return !isInvalid();
}
@Override
public void onReady()
{
super.onReady();
if ( worldObj.getBlock( xCoord, yCoord, zCoord ) == AEApi.instance().blocks().blockQuantumRing.block() )
gridProxy.setVisualRepresentation( ring );
}
@Override
public void invalidate()
{
disconnect( false );
super.invalidate();
}
@Override
public void onChunkUnload()
{
disconnect( false );
super.onChunkUnload();
}
public void updateStatus(QuantumCluster c, byte flags, boolean affectWorld)
{
clust = c;
if ( affectWorld )
{
if ( xdex != flags )
{
xdex = flags;
markForUpdate();
}
if ( isCorner() || isCenter() )
{
gridProxy.setValidSides( getConnections() );
}
else
gridProxy.setValidSides( EnumSet.allOf( ForgeDirection.class ) );
}
}
public long getQEDest()
{
ItemStack is = inv.getStackInSlot( 0 );
if ( is != null )
{
NBTTagCompound c = is.getTagCompound();
if ( c != null )
return c.getLong( "freq" );
}
return 0;
}
public boolean isCenter()
{
return getBlockType() == AEApi.instance().blocks().blockQuantumLink.block();
}
public boolean isCorner()
{
return (xdex & corner) == corner && xdex != -1;
}
public boolean isPowered()
{
if ( Platform.isClient() )
return (xdex & powered) == powered && xdex != -1;
try
{
return gridProxy.getEnergy().isNetworkPowered();
}
catch (GridAccessException e)
{
// :P
}
return false;
}
public boolean isFormed()
{
return xdex != -1;
}
@Override
public AECableType getCableConnectionType(ForgeDirection dir)
{
return AECableType.DENSE;
}
@Override
public DimensionalCoord getLocation()
{
return new DimensionalCoord( this );
}
public void neighborUpdate()
{
calc.calculateMultiblock( worldObj, getLocation() );
}
public EnumSet<ForgeDirection> getConnections()
{
EnumSet<ForgeDirection> set = EnumSet.noneOf( ForgeDirection.class );
for (ForgeDirection d : ForgeDirection.VALID_DIRECTIONS)
{
TileEntity te = worldObj.getTileEntity( xCoord + d.offsetX, yCoord + d.offsetY, zCoord + d.offsetZ );
if ( te instanceof TileQuantumBridge )
set.add( d );
}
return set;
}
public boolean hasQES()
{
if ( xdex == -1 )
return false;
return (xdex & hasSingularity) == hasSingularity;
}
public void breakCluster()
{
if ( clust != null )
clust.destroy();
}
}