protected void updateAdjacentHandlers() { for (int i = 0; i < 6; i++) { accelerables[i] = null; TileEntity tile = BlockHelper.getAdjacentTileEntity(this, i); if (tile instanceof IAccelerable) { accelerables[i] = (IAccelerable) tile; } } cached = true; }
@Override public TileEntity getNextConnectedTile(EnumFacing direction) { return BlockHelper.getAdjacentTileEntity(duct, direction); }
public static TileEntity getAdjacentTileEntity(World world, BlockPos pos, int side) { return world == null ? null : getAdjacentTileEntity(world, pos, EnumFacing.VALUES[side]); }
protected void updateAdjacentHandlers(boolean packet) { if (ServerHelper.isClientWorld(world)) { return; } boolean curAutoOutput = enableAutoOutput; adjacentTanks[0] = BlockHelper.getAdjacentTileEntity(this, EnumFacing.DOWN) instanceof TileTank; adjacentTanks[1] = BlockHelper.getAdjacentTileEntity(this, EnumFacing.UP) instanceof TileTank; if (!lock && getTankFluid() == null) { enableAutoOutput |= adjacentTanks[0]; } if (packet && curAutoOutput != enableAutoOutput) { sendTilePacket(Side.CLIENT); } cached = true; }
public static boolean isAdjacentEnergyProviderFromSide(TileEntity tile, EnumFacing side) { TileEntity handler = BlockHelper.getAdjacentTileEntity(tile, side); return isEnergyProviderFromSide(handler, side.getOpposite()); }
public static boolean isAdjacentFluidHandler(TileEntity tile, EnumFacing side) { TileEntity handler = BlockHelper.getAdjacentTileEntity(tile, side); return handler != null && handler.hasCapability(FLUID_HANDLER, side.getOpposite()); }
public static boolean isAdjacentEnergyConnectableFromSide(TileEntity tile, EnumFacing side) { TileEntity handler = BlockHelper.getAdjacentTileEntity(tile, side); return isEnergyConnectableFromSide(handler, side.getOpposite()); }
public static boolean isAdjacentEnergyReceiverFromSide(TileEntity tile, EnumFacing side) { TileEntity handler = BlockHelper.getAdjacentTileEntity(tile, side); return isEnergyReceiverFromSide(handler, side.getOpposite()); }
public static boolean isAdjacentEnergyHandler(TileEntity tile, EnumFacing side) { TileEntity handler = BlockHelper.getAdjacentTileEntity(tile, side); return handler != null && handler.hasCapability(ENERGY_HANDLER, side.getOpposite()); }
public static TileEntity getAdjacentTileEntity(TileEntity refTile, EnumFacing dir) { return refTile == null ? null : getAdjacentTileEntity(refTile.getWorld(), refTile.getPos(), dir); }
public static TileEntity getAdjacentTileEntity(TileEntity refTile, int side) { return refTile == null ? null : getAdjacentTileEntity(refTile.getWorld(), refTile.getPos(), EnumFacing.VALUES[side]); }
@Override public IGridTile getPhysicalConnectedSide(byte direction) { if (rangePos[direction] != null) { TileEntity adjacentTileEntity = BlockHelper.getAdjacentTileEntity(parent, direction); DuctUnitTransportBase ductUnitTransportBase = IDuctHolder.getTokenFromTile(adjacentTileEntity, DuctToken.TRANSPORT); if (ductUnitTransportBase instanceof DuctUnitTransportLongRange) { return ductUnitTransportBase; } return null; } IGridTile physicalConnectedSide = super.getPhysicalConnectedSide(direction); if (physicalConnectedSide instanceof DuctUnitTransportLongRange) { return null; } return physicalConnectedSide; }
public static FluidStack extractFluidFromAdjacentFluidHandler(TileEntity tile, EnumFacing side, int maxDrain, boolean doDrain) { TileEntity handler = BlockHelper.getAdjacentTileEntity(tile, side); if (handler != null && handler.hasCapability(FLUID_HANDLER, side.getOpposite())) { IFluidHandler cap = handler.getCapability(FLUID_HANDLER, side.getOpposite()); return cap != null ? cap.drain(maxDrain, doDrain) : null; } return null; }
public static int insertFluidIntoAdjacentFluidHandler(World world, BlockPos pos, EnumFacing side, FluidStack fluid, boolean doFill) { TileEntity handler = BlockHelper.getAdjacentTileEntity(world, pos, side); if (handler != null && handler.hasCapability(FLUID_HANDLER, side.getOpposite())) { IFluidHandler cap = handler.getCapability(FLUID_HANDLER, side.getOpposite()); return cap != null ? cap.fill(fluid, doFill) : 0; } return 0; }
public static boolean canAdjacentEnergyHandlerExtract(TileEntity tile, EnumFacing side) { TileEntity handler = BlockHelper.getAdjacentTileEntity(tile, side); if (handler != null && handler.hasCapability(ENERGY_HANDLER, side.getOpposite())) { IEnergyStorage storage = handler.getCapability(ENERGY_HANDLER, side.getOpposite()); if (storage != null) { return storage.canExtract(); } } return false; }
public static int insertFluidIntoAdjacentFluidHandler(TileEntity tile, EnumFacing side, FluidStack fluid, boolean doFill) { TileEntity handler = BlockHelper.getAdjacentTileEntity(tile, side); if (handler != null && handler.hasCapability(FLUID_HANDLER, side.getOpposite())) { IFluidHandler cap = handler.getCapability(FLUID_HANDLER, side.getOpposite()); return cap != null ? cap.fill(fluid, doFill) : 0; } return 0; }
public static boolean canAdjacentEnergyHandlerReceive(TileEntity tile, EnumFacing side) { TileEntity handler = BlockHelper.getAdjacentTileEntity(tile, side); if (handler != null && handler.hasCapability(ENERGY_HANDLER, side.getOpposite())) { IEnergyStorage storage = handler.getCapability(ENERGY_HANDLER, side.getOpposite()); if (storage != null) { return storage.canReceive(); } } return false; }
public static int extractEnergyFromAdjacentEnergyProvider(TileEntity tile, EnumFacing side, int energy, boolean simulate) { TileEntity handler = BlockHelper.getAdjacentTileEntity(tile, side); if (handler instanceof IEnergyProvider) { return ((IEnergyProvider) handler).extractEnergy(side.getOpposite(), energy, simulate); } else if (handler != null && handler.hasCapability(ENERGY_HANDLER, side.getOpposite())) { return handler.getCapability(ENERGY_HANDLER, side.getOpposite()).extractEnergy(energy, simulate); } return 0; }
public static int insertEnergyIntoAdjacentEnergyReceiver(TileEntity tile, EnumFacing side, int energy, boolean simulate) { TileEntity handler = BlockHelper.getAdjacentTileEntity(tile, side); if (handler instanceof IEnergyReceiver) { return ((IEnergyReceiver) handler).receiveEnergy(side.getOpposite(), energy, simulate); } else if (handler != null && handler.hasCapability(ENERGY_HANDLER, side.getOpposite())) { return handler.getCapability(ENERGY_HANDLER, side.getOpposite()).receiveEnergy(energy, simulate); } return 0; }
@Override public void onNeighborChange() { super.onNeighborChange(); TileEntity adjacentTileEntity = BlockHelper.getAdjacentTileEntity(baseTile, side); clearCache(); boolean wasValidInput = isValidInput; isValidInput = isValidTile(adjacentTileEntity); if (isValidInput) { cacheTile(adjacentTileEntity); } boolean wasPowered = isPowered; isPowered = rsMode.isDisabled() || rsMode.getState() == getPowerState(); if (wasPowered != isPowered || isValidInput != wasValidInput) { BlockHelper.callBlockUpdate(baseTile.getWorld(), baseTile.getPos()); } }