500fc47490
Reduces the visibility of all fields to private and create setters/getters when necessary. Exceptions are fields with GuiSync as these need to be public. Reduces the visibility of internal methods to private/protected/default when possible.
537 lines
15 KiB
Java
537 lines
15 KiB
Java
/*
|
|
* This file is part of Applied Energistics 2.
|
|
* Copyright (c) 2013 - 2015, AlgorithmX2, All rights reserved.
|
|
*
|
|
* Applied Energistics 2 is free software: you can redistribute it and/or modify
|
|
* it under the terms of the GNU Lesser General Public License as published by
|
|
* the Free Software Foundation, either version 3 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* Applied Energistics 2 is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU Lesser General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Lesser General Public License
|
|
* along with Applied Energistics 2. If not, see <http://www.gnu.org/licenses/lgpl>.
|
|
*/
|
|
|
|
package appeng.block.networking;
|
|
|
|
|
|
import java.util.EnumSet;
|
|
import java.util.List;
|
|
import java.util.Random;
|
|
|
|
import net.minecraft.block.Block;
|
|
import net.minecraft.client.particle.EffectRenderer;
|
|
import net.minecraft.client.particle.EntityDiggingFX;
|
|
import net.minecraft.client.renderer.texture.IIconRegister;
|
|
import net.minecraft.creativetab.CreativeTabs;
|
|
import net.minecraft.entity.Entity;
|
|
import net.minecraft.entity.EntityLivingBase;
|
|
import net.minecraft.entity.player.EntityPlayer;
|
|
import net.minecraft.item.Item;
|
|
import net.minecraft.item.ItemStack;
|
|
import net.minecraft.tileentity.TileEntity;
|
|
import net.minecraft.util.IIcon;
|
|
import net.minecraft.util.MovingObjectPosition;
|
|
import net.minecraft.util.Vec3;
|
|
import net.minecraft.world.IBlockAccess;
|
|
import net.minecraft.world.World;
|
|
import net.minecraftforge.common.util.ForgeDirection;
|
|
|
|
import cpw.mods.fml.common.registry.GameRegistry;
|
|
import cpw.mods.fml.relauncher.Side;
|
|
import cpw.mods.fml.relauncher.SideOnly;
|
|
|
|
import powercrystals.minefactoryreloaded.api.rednet.connectivity.IRedNetConnection;
|
|
import powercrystals.minefactoryreloaded.api.rednet.connectivity.RedNetConnectionType;
|
|
|
|
import appeng.api.parts.IPart;
|
|
import appeng.api.parts.IPartHost;
|
|
import appeng.api.parts.PartItemStack;
|
|
import appeng.api.parts.SelectedPart;
|
|
import appeng.api.util.AEColor;
|
|
import appeng.block.AEBaseTileBlock;
|
|
import appeng.client.render.BaseBlockRender;
|
|
import appeng.client.render.BusRenderHelper;
|
|
import appeng.client.render.blocks.RendererCableBus;
|
|
import appeng.client.texture.ExtraBlockTextures;
|
|
import appeng.core.AEConfig;
|
|
import appeng.core.Api;
|
|
import appeng.core.CommonHelper;
|
|
import appeng.core.features.AECableBusFeatureHandler;
|
|
import appeng.core.features.AEFeature;
|
|
import appeng.helpers.AEGlassMaterial;
|
|
import appeng.helpers.Reflected;
|
|
import appeng.integration.IntegrationRegistry;
|
|
import appeng.integration.IntegrationType;
|
|
import appeng.integration.abstraction.IFMP;
|
|
import appeng.parts.ICableBusContainer;
|
|
import appeng.parts.NullCableBusContainer;
|
|
import appeng.tile.AEBaseTile;
|
|
import appeng.tile.networking.TileCableBus;
|
|
import appeng.tile.networking.TileCableBusTESR;
|
|
import appeng.transformer.annotations.Integration.Interface;
|
|
import appeng.transformer.annotations.Integration.Method;
|
|
import appeng.util.Platform;
|
|
|
|
|
|
@Interface( iface = "powercrystals.minefactoryreloaded.api.rednet.connectivity.IRedNetConnection", iname = IntegrationType.MFR )
|
|
public class BlockCableBus extends AEBaseTileBlock implements IRedNetConnection
|
|
{
|
|
|
|
private static final ICableBusContainer NULL_CABLE_BUS = new NullCableBusContainer();
|
|
private static Class<? extends TileEntity> noTesrTile;
|
|
private static Class<? extends TileEntity> tesrTile;
|
|
|
|
/**
|
|
* Immibis MB Support.
|
|
*
|
|
* It will look for a field named ImmibisMicroblocks_TransformableBlockMarker or
|
|
* ImmibisMicroblocks_TransformableTileEntityMarker, modifiers, type, etc can be ignored.
|
|
*/
|
|
@Reflected
|
|
private static final boolean ImmibisMicroblocks_TransformableBlockMarker = true;
|
|
|
|
private int myColorMultiplier = 0xffffff;
|
|
|
|
public BlockCableBus()
|
|
{
|
|
super( AEGlassMaterial.INSTANCE );
|
|
this.setLightOpacity( 0 );
|
|
this.isFullSize = this.isOpaque = false;
|
|
|
|
// this will actually be overwritten later through setupTile and the combined layers
|
|
this.setTileEntity( TileCableBus.class );
|
|
this.setFeature( EnumSet.of( AEFeature.Core ) );
|
|
}
|
|
|
|
@Override
|
|
public void randomDisplayTick( final World world, final int x, final int y, final int z, final Random r )
|
|
{
|
|
this.cb( world, x, y, z ).randomDisplayTick( world, x, y, z, r );
|
|
}
|
|
|
|
@Override
|
|
public void onNeighborBlockChange( final World w, final int x, final int y, final int z, final Block meh )
|
|
{
|
|
this.cb( w, x, y, z ).onNeighborChanged();
|
|
}
|
|
|
|
@Override
|
|
public Item getItemDropped( final int i, final Random r, final int k )
|
|
{
|
|
return null;
|
|
}
|
|
|
|
@Override
|
|
public int getRenderBlockPass()
|
|
{
|
|
if( AEConfig.instance.isFeatureEnabled( AEFeature.AlphaPass ) )
|
|
{
|
|
return 1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
@Override
|
|
public int colorMultiplier( final IBlockAccess world, final int x, final int y, final int z )
|
|
{
|
|
return this.myColorMultiplier;
|
|
}
|
|
|
|
@Override
|
|
public int isProvidingWeakPower( final IBlockAccess w, final int x, final int y, final int z, final int side )
|
|
{
|
|
return this.cb( w, x, y, z ).isProvidingWeakPower( ForgeDirection.getOrientation( side ).getOpposite() );
|
|
}
|
|
|
|
@Override
|
|
public boolean canProvidePower()
|
|
{
|
|
return true;
|
|
}
|
|
|
|
@Override
|
|
public void onEntityCollidedWithBlock( final World w, final int x, final int y, final int z, final Entity e )
|
|
{
|
|
this.cb( w, x, y, z ).onEntityCollision( e );
|
|
}
|
|
|
|
@Override
|
|
public int isProvidingStrongPower( final IBlockAccess w, final int x, final int y, final int z, final int side )
|
|
{
|
|
return this.cb( w, x, y, z ).isProvidingStrongPower( ForgeDirection.getOrientation( side ).getOpposite() );
|
|
}
|
|
|
|
@Override
|
|
public int getLightValue( final IBlockAccess world, final int x, final int y, final int z )
|
|
{
|
|
final Block block = world.getBlock( x, y, z );
|
|
if( block != null && block != this )
|
|
{
|
|
return block.getLightValue( world, x, y, z );
|
|
}
|
|
if( block == null )
|
|
{
|
|
return 0;
|
|
}
|
|
return this.cb( world, x, y, z ).getLightValue();
|
|
}
|
|
|
|
@Override
|
|
public boolean isLadder( final IBlockAccess world, final int x, final int y, final int z, final EntityLivingBase entity )
|
|
{
|
|
return this.cb( world, x, y, z ).isLadder( entity );
|
|
}
|
|
|
|
@Override
|
|
public boolean isSideSolid( final IBlockAccess w, final int x, final int y, final int z, final ForgeDirection side )
|
|
{
|
|
return this.cb( w, x, y, z ).isSolidOnSide( side );
|
|
}
|
|
|
|
@Override
|
|
public boolean isReplaceable( final IBlockAccess world, final int x, final int y, final int z )
|
|
{
|
|
return this.cb( world, x, y, z ).isEmpty();
|
|
}
|
|
|
|
@SuppressWarnings( "deprecation" )
|
|
@Override
|
|
public boolean removedByPlayer( final World world, final EntityPlayer player, final int x, final int y, final int z )
|
|
{
|
|
if( player.capabilities.isCreativeMode )
|
|
{
|
|
final AEBaseTile tile = this.getTileEntity( world, x, y, z );
|
|
if( tile != null )
|
|
{
|
|
tile.disableDrops();
|
|
}
|
|
// maybe ray trace?
|
|
}
|
|
return super.removedByPlayer( world, player, x, y, z );
|
|
}
|
|
|
|
@Override
|
|
public boolean canConnectRedstone( final IBlockAccess w, final int x, final int y, final int z, final int side )
|
|
{
|
|
switch( side )
|
|
{
|
|
case -1:
|
|
case 4:
|
|
return this.cb( w, x, y, z ).canConnectRedstone( EnumSet.of( ForgeDirection.UP, ForgeDirection.DOWN ) );
|
|
case 0:
|
|
return this.cb( w, x, y, z ).canConnectRedstone( EnumSet.of( ForgeDirection.NORTH ) );
|
|
case 1:
|
|
return this.cb( w, x, y, z ).canConnectRedstone( EnumSet.of( ForgeDirection.EAST ) );
|
|
case 2:
|
|
return this.cb( w, x, y, z ).canConnectRedstone( EnumSet.of( ForgeDirection.SOUTH ) );
|
|
case 3:
|
|
return this.cb( w, x, y, z ).canConnectRedstone( EnumSet.of( ForgeDirection.WEST ) );
|
|
}
|
|
return false;
|
|
}
|
|
|
|
@Override
|
|
public boolean canRenderInPass( final int pass )
|
|
{
|
|
BusRenderHelper.INSTANCE.setPass( pass );
|
|
|
|
if( AEConfig.instance.isFeatureEnabled( AEFeature.AlphaPass ) )
|
|
{
|
|
return true;
|
|
}
|
|
|
|
return pass == 0;
|
|
}
|
|
|
|
@Override
|
|
public ItemStack getPickBlock( final MovingObjectPosition target, final World world, final int x, final int y, final int z, final EntityPlayer player )
|
|
{
|
|
final Vec3 v3 = target.hitVec.addVector( -x, -y, -z );
|
|
final SelectedPart sp = this.cb( world, x, y, z ).selectPart( v3 );
|
|
|
|
if( sp.part != null )
|
|
{
|
|
return sp.part.getItemStack( PartItemStack.Pick );
|
|
}
|
|
else if( sp.facade != null )
|
|
{
|
|
return sp.facade.getItemStack();
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
@Override
|
|
@SideOnly( Side.CLIENT )
|
|
public boolean addHitEffects( final World world, final MovingObjectPosition target, final EffectRenderer effectRenderer )
|
|
{
|
|
final Object object = this.cb( world, target.blockX, target.blockY, target.blockZ );
|
|
if( object instanceof IPartHost )
|
|
{
|
|
final IPartHost host = (IPartHost) object;
|
|
|
|
for( final ForgeDirection side : ForgeDirection.values() )
|
|
{
|
|
final IPart p = host.getPart( side );
|
|
final IIcon ico = this.getIcon( p );
|
|
|
|
if( ico == null )
|
|
{
|
|
continue;
|
|
}
|
|
|
|
final byte b0 = (byte) ( Platform.getRandomInt() % 2 == 0 ? 1 : 0 );
|
|
|
|
for( int i1 = 0; i1 < b0; ++i1 )
|
|
{
|
|
for( int j1 = 0; j1 < b0; ++j1 )
|
|
{
|
|
for( int k1 = 0; k1 < b0; ++k1 )
|
|
{
|
|
final double d0 = target.blockX + ( i1 + 0.5D ) / b0;
|
|
final double d1 = target.blockY + ( j1 + 0.5D ) / b0;
|
|
final double d2 = target.blockZ + ( k1 + 0.5D ) / b0;
|
|
|
|
final double dd0 = target.hitVec.xCoord;
|
|
final double dd1 = target.hitVec.yCoord;
|
|
final double dd2 = target.hitVec.zCoord;
|
|
final EntityDiggingFX fx = ( new EntityDiggingFX( world, dd0, dd1, dd2, d0 - target.blockX - 0.5D, d1 - target.blockY - 0.5D, d2 - target.blockZ - 0.5D, this, 0 ) ).applyColourMultiplier( target.blockX, target.blockY, target.blockZ );
|
|
|
|
fx.setParticleIcon( ico );
|
|
|
|
effectRenderer.addEffect( fx );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
@Override
|
|
@SideOnly( Side.CLIENT )
|
|
public boolean addDestroyEffects( final World world, final int x, final int y, final int z, final int meta, final EffectRenderer effectRenderer )
|
|
{
|
|
final Object object = this.cb( world, x, y, z );
|
|
if( object instanceof IPartHost )
|
|
{
|
|
final IPartHost host = (IPartHost) object;
|
|
|
|
for( final ForgeDirection side : ForgeDirection.values() )
|
|
{
|
|
final IPart p = host.getPart( side );
|
|
final IIcon ico = this.getIcon( p );
|
|
|
|
if( ico == null )
|
|
{
|
|
continue;
|
|
}
|
|
|
|
final byte b0 = 3;
|
|
|
|
for( int i1 = 0; i1 < b0; ++i1 )
|
|
{
|
|
for( int j1 = 0; j1 < b0; ++j1 )
|
|
{
|
|
for( int k1 = 0; k1 < b0; ++k1 )
|
|
{
|
|
final double d0 = x + ( i1 + 0.5D ) / b0;
|
|
final double d1 = y + ( j1 + 0.5D ) / b0;
|
|
final double d2 = z + ( k1 + 0.5D ) / b0;
|
|
final EntityDiggingFX fx = ( new EntityDiggingFX( world, d0, d1, d2, d0 - x - 0.5D, d1 - y - 0.5D, d2 - z - 0.5D, this, meta ) ).applyColourMultiplier( x, y, z );
|
|
|
|
fx.setParticleIcon( ico );
|
|
|
|
effectRenderer.addEffect( fx );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
@Override
|
|
public void onNeighborChange( final IBlockAccess w, final int x, final int y, final int z, final int tileX, final int tileY, final int tileZ )
|
|
{
|
|
if( Platform.isServer() )
|
|
{
|
|
this.cb( w, x, y, z ).onNeighborChanged();
|
|
}
|
|
}
|
|
|
|
private IIcon getIcon( final IPart p )
|
|
{
|
|
if( p == null )
|
|
{
|
|
return null;
|
|
}
|
|
|
|
try
|
|
{
|
|
final IIcon ico = p.getBreakingTexture();
|
|
if( ico != null )
|
|
{
|
|
return ico;
|
|
}
|
|
}
|
|
catch( final Throwable t )
|
|
{
|
|
// nothing.
|
|
}
|
|
|
|
final ItemStack is = p.getItemStack( PartItemStack.Network );
|
|
if( is == null || is.getItem() == null )
|
|
{
|
|
return null;
|
|
}
|
|
|
|
return is.getItem().getIcon( is, 0 );
|
|
}
|
|
|
|
private ICableBusContainer cb( final IBlockAccess w, final int x, final int y, final int z )
|
|
{
|
|
final TileEntity te = w.getTileEntity( x, y, z );
|
|
ICableBusContainer out = null;
|
|
|
|
if( te instanceof TileCableBus )
|
|
{
|
|
out = ( (TileCableBus) te ).getCableBus();
|
|
}
|
|
else if( IntegrationRegistry.INSTANCE.isEnabled( IntegrationType.FMP ) )
|
|
{
|
|
out = ( (IFMP) IntegrationRegistry.INSTANCE.getInstance( IntegrationType.FMP ) ).getCableContainer( te );
|
|
}
|
|
|
|
return out == null ? NULL_CABLE_BUS : out;
|
|
}
|
|
|
|
@Override
|
|
protected Class<? extends BaseBlockRender> getRenderer()
|
|
{
|
|
return RendererCableBus.class;
|
|
}
|
|
|
|
@Override
|
|
public IIcon getIcon( final IBlockAccess w, final int x, final int y, final int z, final int s )
|
|
{
|
|
return this.getIcon( s, 0 );
|
|
}
|
|
|
|
@Override
|
|
public IIcon getIcon( final int direction, final int metadata )
|
|
{
|
|
final IIcon i = super.getIcon( direction, metadata );
|
|
if( i != null )
|
|
{
|
|
return i;
|
|
}
|
|
|
|
return ExtraBlockTextures.BlockQuartzGlassB.getIcon();
|
|
}
|
|
|
|
@Override
|
|
public boolean onActivated( final World w, final int x, final int y, final int z, final EntityPlayer player, final int side, final float hitX, final float hitY, final float hitZ )
|
|
{
|
|
return this.cb( w, x, y, z ).activate( player, Vec3.createVectorHelper( hitX, hitY, hitZ ) );
|
|
}
|
|
|
|
@Override
|
|
public void registerBlockIcons( final IIconRegister iconRegistry )
|
|
{
|
|
|
|
}
|
|
|
|
@Override
|
|
public boolean recolourBlock( final World world, final int x, final int y, final int z, final ForgeDirection side, final int colour )
|
|
{
|
|
return this.recolourBlock( world, x, y, z, side, colour, null );
|
|
}
|
|
|
|
public boolean recolourBlock( final World world, final int x, final int y, final int z, final ForgeDirection side, final int colour, final EntityPlayer who )
|
|
{
|
|
try
|
|
{
|
|
return this.cb( world, x, y, z ).recolourBlock( side, AEColor.values()[colour], who );
|
|
}
|
|
catch( final Throwable ignored )
|
|
{
|
|
}
|
|
return false;
|
|
}
|
|
|
|
@Override
|
|
@SideOnly( Side.CLIENT )
|
|
public void getCheckedSubBlocks( final Item item, final CreativeTabs tabs, final List<ItemStack> itemStacks )
|
|
{
|
|
// do nothing
|
|
}
|
|
|
|
@Override
|
|
public <T extends AEBaseTile> T getTileEntity( final IBlockAccess w, final int x, final int y, final int z )
|
|
{
|
|
final TileEntity te = w.getTileEntity( x, y, z );
|
|
|
|
if( noTesrTile.isInstance( te ) )
|
|
{
|
|
return (T) te;
|
|
}
|
|
|
|
if( tesrTile != null && tesrTile.isInstance( te ) )
|
|
{
|
|
return (T) te;
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
@Override
|
|
protected void setFeature( final EnumSet<AEFeature> f )
|
|
{
|
|
final AECableBusFeatureHandler featureHandler = new AECableBusFeatureHandler( f, this, this.featureSubName );
|
|
this.setHandler( featureHandler );
|
|
}
|
|
|
|
public void setupTile()
|
|
{
|
|
noTesrTile = Api.INSTANCE.partHelper().getCombinedInstance( TileCableBus.class.getName() );
|
|
this.setTileEntity( noTesrTile );
|
|
GameRegistry.registerTileEntity( noTesrTile, "BlockCableBus" );
|
|
if( Platform.isClient() )
|
|
{
|
|
tesrTile = Api.INSTANCE.partHelper().getCombinedInstance( TileCableBusTESR.class.getName() );
|
|
GameRegistry.registerTileEntity( tesrTile, "ClientOnly_TESR_CableBus" );
|
|
CommonHelper.proxy.bindTileEntitySpecialRenderer( tesrTile, this );
|
|
}
|
|
}
|
|
|
|
@Override
|
|
@Method( iname = IntegrationType.MFR )
|
|
public RedNetConnectionType getConnectionType( final World world, final int x, final int y, final int z, final ForgeDirection side )
|
|
{
|
|
return this.cb( world, x, y, z ).canConnectRedstone( EnumSet.allOf( ForgeDirection.class ) ) ? RedNetConnectionType.CableSingle : RedNetConnectionType.None;
|
|
}
|
|
|
|
public void setRenderColor( final int color )
|
|
{
|
|
this.myColorMultiplier = color;
|
|
}
|
|
|
|
public static Class<? extends TileEntity> getTesrTile()
|
|
{
|
|
return BlockCableBus.tesrTile;
|
|
}
|
|
|
|
public static Class<? extends TileEntity> getNoTesrTile()
|
|
{
|
|
return BlockCableBus.noTesrTile;
|
|
}
|
|
}
|