Salomão
537 lines
14 KiB
Java
537 lines
14 KiB
Java
/*
|
|
* This file is part of Applied Energistics 2.
|
|
* Copyright (c) 2013 - 2014, 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.tile.storage;
|
|
|
|
|
|
import java.util.IdentityHashMap;
|
|
import java.util.List;
|
|
import java.util.Map;
|
|
|
|
import net.minecraft.block.Block;
|
|
import net.minecraft.item.ItemStack;
|
|
import net.minecraft.nbt.NBTTagCompound;
|
|
import net.minecraft.util.EnumFacing;
|
|
import net.minecraft.util.math.BlockPos;
|
|
import net.minecraft.world.World;
|
|
import net.minecraftforge.items.IItemHandler;
|
|
|
|
import appeng.api.AEApi;
|
|
import appeng.api.config.Actionable;
|
|
import appeng.api.config.FullnessMode;
|
|
import appeng.api.config.OperationMode;
|
|
import appeng.api.config.RedstoneMode;
|
|
import appeng.api.config.Settings;
|
|
import appeng.api.config.Upgrades;
|
|
import appeng.api.config.YesNo;
|
|
import appeng.api.implementations.IUpgradeableHost;
|
|
import appeng.api.networking.GridFlags;
|
|
import appeng.api.networking.IGridNode;
|
|
import appeng.api.networking.energy.IEnergySource;
|
|
import appeng.api.networking.security.IActionSource;
|
|
import appeng.api.networking.ticking.IGridTickable;
|
|
import appeng.api.networking.ticking.TickRateModulation;
|
|
import appeng.api.networking.ticking.TickingRequest;
|
|
import appeng.api.storage.IMEInventory;
|
|
import appeng.api.storage.IMEMonitor;
|
|
import appeng.api.storage.IStorageChannel;
|
|
import appeng.api.storage.data.IAEStack;
|
|
import appeng.api.storage.data.IItemList;
|
|
import appeng.api.util.AECableType;
|
|
import appeng.api.util.AEPartLocation;
|
|
import appeng.api.util.DimensionalCoord;
|
|
import appeng.api.util.IConfigManager;
|
|
import appeng.core.settings.TickRates;
|
|
import appeng.me.GridAccessException;
|
|
import appeng.me.helpers.MachineSource;
|
|
import appeng.parts.automation.BlockUpgradeInventory;
|
|
import appeng.parts.automation.UpgradeInventory;
|
|
import appeng.tile.grid.AENetworkInvTile;
|
|
import appeng.tile.inventory.AppEngInternalInventory;
|
|
import appeng.util.ConfigManager;
|
|
import appeng.util.IConfigManagerHost;
|
|
import appeng.util.InventoryAdaptor;
|
|
import appeng.util.Platform;
|
|
import appeng.util.helpers.ItemHandlerUtil;
|
|
import appeng.util.inv.AdaptorItemHandler;
|
|
import appeng.util.inv.InvOperation;
|
|
import appeng.util.inv.WrapperChainedItemHandler;
|
|
import appeng.util.inv.WrapperFilteredItemHandler;
|
|
import appeng.util.inv.filter.AEItemFilters;
|
|
|
|
|
|
public class TileIOPort extends AENetworkInvTile implements IUpgradeableHost, IConfigManagerHost, IGridTickable
|
|
{
|
|
private static final int NUMBER_OF_CELL_SLOTS = 6;
|
|
private static final int NUMBER_OF_UPGRADE_SLOTS = 3;
|
|
|
|
private final ConfigManager manager;
|
|
|
|
private final AppEngInternalInventory inputCells = new AppEngInternalInventory( this, NUMBER_OF_CELL_SLOTS );
|
|
private final AppEngInternalInventory outputCells = new AppEngInternalInventory( this, NUMBER_OF_CELL_SLOTS );
|
|
private final IItemHandler combinedInventory = new WrapperChainedItemHandler( this.inputCells, this.outputCells );
|
|
|
|
private final IItemHandler inputCellsExt = new WrapperFilteredItemHandler( this.inputCells, AEItemFilters.INSERT_ONLY );
|
|
private final IItemHandler outputCellsExt = new WrapperFilteredItemHandler( this.outputCells, AEItemFilters.EXTRACT_ONLY );
|
|
|
|
private final UpgradeInventory upgrades;
|
|
private final IActionSource mySrc;
|
|
private YesNo lastRedstoneState;
|
|
private ItemStack currentCell;
|
|
private Map<IStorageChannel<?>, IMEInventory<?>> cachedInventories;
|
|
|
|
public TileIOPort()
|
|
{
|
|
this.getProxy().setFlags( GridFlags.REQUIRE_CHANNEL );
|
|
this.manager = new ConfigManager( this );
|
|
this.manager.registerSetting( Settings.REDSTONE_CONTROLLED, RedstoneMode.IGNORE );
|
|
this.manager.registerSetting( Settings.FULLNESS_MODE, FullnessMode.EMPTY );
|
|
this.manager.registerSetting( Settings.OPERATION_MODE, OperationMode.EMPTY );
|
|
this.mySrc = new MachineSource( this );
|
|
this.lastRedstoneState = YesNo.UNDECIDED;
|
|
|
|
final Block ioPortBlock = AEApi.instance().definitions().blocks().iOPort().maybeBlock().get();
|
|
this.upgrades = new BlockUpgradeInventory( ioPortBlock, this, NUMBER_OF_UPGRADE_SLOTS );
|
|
}
|
|
|
|
@Override
|
|
public NBTTagCompound writeToNBT( final NBTTagCompound data )
|
|
{
|
|
super.writeToNBT( data );
|
|
this.manager.writeToNBT( data );
|
|
this.upgrades.writeToNBT( data, "upgrades" );
|
|
data.setInteger( "lastRedstoneState", this.lastRedstoneState.ordinal() );
|
|
return data;
|
|
}
|
|
|
|
@Override
|
|
public void readFromNBT( final NBTTagCompound data )
|
|
{
|
|
super.readFromNBT( data );
|
|
this.manager.readFromNBT( data );
|
|
this.upgrades.readFromNBT( data, "upgrades" );
|
|
if( data.hasKey( "lastRedstoneState" ) )
|
|
{
|
|
this.lastRedstoneState = YesNo.values()[data.getInteger( "lastRedstoneState" )];
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public AECableType getCableConnectionType( final AEPartLocation dir )
|
|
{
|
|
return AECableType.SMART;
|
|
}
|
|
|
|
@Override
|
|
public DimensionalCoord getLocation()
|
|
{
|
|
return new DimensionalCoord( this );
|
|
}
|
|
|
|
private void updateTask()
|
|
{
|
|
try
|
|
{
|
|
if( this.hasWork() )
|
|
{
|
|
this.getProxy().getTick().wakeDevice( this.getProxy().getNode() );
|
|
}
|
|
else
|
|
{
|
|
this.getProxy().getTick().sleepDevice( this.getProxy().getNode() );
|
|
}
|
|
}
|
|
catch( final GridAccessException e )
|
|
{
|
|
// :P
|
|
}
|
|
}
|
|
|
|
public void updateRedstoneState()
|
|
{
|
|
final YesNo currentState = this.world.isBlockIndirectlyGettingPowered( this.pos ) != 0 ? YesNo.YES : YesNo.NO;
|
|
if( this.lastRedstoneState != currentState )
|
|
{
|
|
this.lastRedstoneState = currentState;
|
|
this.updateTask();
|
|
}
|
|
}
|
|
|
|
private boolean getRedstoneState()
|
|
{
|
|
if( this.lastRedstoneState == YesNo.UNDECIDED )
|
|
{
|
|
this.updateRedstoneState();
|
|
}
|
|
|
|
return this.lastRedstoneState == YesNo.YES;
|
|
}
|
|
|
|
private boolean isEnabled()
|
|
{
|
|
if( this.getInstalledUpgrades( Upgrades.REDSTONE ) == 0 )
|
|
{
|
|
return true;
|
|
}
|
|
|
|
final RedstoneMode rs = (RedstoneMode) this.manager.getSetting( Settings.REDSTONE_CONTROLLED );
|
|
if( rs == RedstoneMode.HIGH_SIGNAL )
|
|
{
|
|
return this.getRedstoneState();
|
|
}
|
|
return !this.getRedstoneState();
|
|
}
|
|
|
|
@Override
|
|
public IConfigManager getConfigManager()
|
|
{
|
|
return this.manager;
|
|
}
|
|
|
|
@Override
|
|
public IItemHandler getInventoryByName( final String name )
|
|
{
|
|
if( name.equals( "upgrades" ) )
|
|
{
|
|
return this.upgrades;
|
|
}
|
|
|
|
if( name.equals( "cells" ) )
|
|
{
|
|
return this.combinedInventory;
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
@Override
|
|
public void updateSetting( final IConfigManager manager, final Enum settingName, final Enum newValue )
|
|
{
|
|
this.updateTask();
|
|
}
|
|
|
|
private boolean hasWork()
|
|
{
|
|
if( this.isEnabled() )
|
|
{
|
|
return !ItemHandlerUtil.isEmpty( this.inputCells );
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
@Override
|
|
public IItemHandler getInternalInventory()
|
|
{
|
|
return this.combinedInventory;
|
|
}
|
|
|
|
@Override
|
|
public void onChangeInventory( final IItemHandler inv, final int slot, final InvOperation mc, final ItemStack removed, final ItemStack added )
|
|
{
|
|
if( this.inputCells == inv )
|
|
{
|
|
this.updateTask();
|
|
}
|
|
}
|
|
|
|
@Override
|
|
protected IItemHandler getItemHandlerForSide( final EnumFacing facing )
|
|
{
|
|
if( facing == this.getUp() || facing == this.getUp().getOpposite() )
|
|
{
|
|
return this.inputCellsExt;
|
|
}
|
|
else
|
|
{
|
|
return this.outputCellsExt;
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public TickingRequest getTickingRequest( final IGridNode node )
|
|
{
|
|
return new TickingRequest( TickRates.IOPort.getMin(), TickRates.IOPort.getMax(), !this.hasWork(), false );
|
|
}
|
|
|
|
@Override
|
|
public TickRateModulation tickingRequest( final IGridNode node, final int ticksSinceLastCall )
|
|
{
|
|
if( !this.getProxy().isActive() )
|
|
{
|
|
return TickRateModulation.IDLE;
|
|
}
|
|
|
|
TickRateModulation ret = TickRateModulation.SLEEP;
|
|
long itemsToMove = 256;
|
|
|
|
switch( this.getInstalledUpgrades( Upgrades.SPEED ) )
|
|
{
|
|
case 1:
|
|
itemsToMove *= 2;
|
|
break;
|
|
case 2:
|
|
itemsToMove *= 4;
|
|
break;
|
|
case 3:
|
|
itemsToMove *= 8;
|
|
break;
|
|
}
|
|
|
|
try
|
|
{
|
|
final IEnergySource energy = this.getProxy().getEnergy();
|
|
for( int x = 0; x < NUMBER_OF_CELL_SLOTS; x++ )
|
|
{
|
|
final ItemStack is = this.inputCells.getStackInSlot( x );
|
|
if( !is.isEmpty() )
|
|
{
|
|
boolean shouldMove = true;
|
|
|
|
for( IStorageChannel<? extends IAEStack<?>> c : AEApi.instance().storage().storageChannels() )
|
|
{
|
|
if( itemsToMove > 0 )
|
|
{
|
|
final IMEMonitor<? extends IAEStack<?>> network = this.getProxy().getStorage().getInventory( c );
|
|
final IMEInventory<?> inv = this.getInv( is, c );
|
|
|
|
if( inv == null )
|
|
{
|
|
continue;
|
|
}
|
|
|
|
if( this.manager.getSetting( Settings.OPERATION_MODE ) == OperationMode.EMPTY )
|
|
{
|
|
itemsToMove = this.transferContents( energy, inv, network, itemsToMove, c );
|
|
}
|
|
else
|
|
{
|
|
itemsToMove = this.transferContents( energy, network, inv, itemsToMove, c );
|
|
}
|
|
|
|
shouldMove &= this.shouldMove( inv );
|
|
|
|
if( itemsToMove > 0 )
|
|
{
|
|
ret = TickRateModulation.IDLE;
|
|
}
|
|
else
|
|
{
|
|
ret = TickRateModulation.URGENT;
|
|
}
|
|
}
|
|
}
|
|
|
|
if( itemsToMove > 0 && shouldMove && this.moveSlot( x ) )
|
|
{
|
|
ret = TickRateModulation.URGENT;
|
|
}
|
|
else
|
|
{
|
|
ret = TickRateModulation.URGENT;
|
|
}
|
|
|
|
}
|
|
}
|
|
}
|
|
catch( final GridAccessException e )
|
|
{
|
|
ret = TickRateModulation.IDLE;
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
@Override
|
|
public int getInstalledUpgrades( final Upgrades u )
|
|
{
|
|
return this.upgrades.getInstalledUpgrades( u );
|
|
}
|
|
|
|
private IMEInventory<?> getInv( final ItemStack is, final IStorageChannel<?> chan )
|
|
{
|
|
if( this.currentCell != is )
|
|
{
|
|
this.currentCell = is;
|
|
this.cachedInventories = new IdentityHashMap<>();
|
|
|
|
for( IStorageChannel<? extends IAEStack<?>> c : AEApi.instance().storage().storageChannels() )
|
|
{
|
|
this.cachedInventories.put( c, AEApi.instance().registries().cell().getCellInventory( is, null, c ) );
|
|
}
|
|
}
|
|
|
|
return this.cachedInventories.get( chan );
|
|
}
|
|
|
|
private long transferContents( final IEnergySource energy, final IMEInventory src, final IMEInventory destination, long itemsToMove, final IStorageChannel chan )
|
|
{
|
|
final IItemList<? extends IAEStack> myList;
|
|
if( src instanceof IMEMonitor )
|
|
{
|
|
myList = ( (IMEMonitor) src ).getStorageList();
|
|
}
|
|
else
|
|
{
|
|
myList = src.getAvailableItems( src.getChannel().createList() );
|
|
}
|
|
|
|
itemsToMove *= chan.transferFactor();
|
|
|
|
boolean didStuff;
|
|
|
|
do
|
|
{
|
|
didStuff = false;
|
|
|
|
for( final IAEStack s : myList )
|
|
{
|
|
final long totalStackSize = s.getStackSize();
|
|
if( totalStackSize > 0 )
|
|
{
|
|
final IAEStack stack = destination.injectItems( s, Actionable.SIMULATE, this.mySrc );
|
|
|
|
long possible = 0;
|
|
if( stack == null )
|
|
{
|
|
possible = totalStackSize;
|
|
}
|
|
else
|
|
{
|
|
possible = totalStackSize - stack.getStackSize();
|
|
}
|
|
|
|
if( possible > 0 )
|
|
{
|
|
IAEStack injectable = s.copy();
|
|
|
|
possible = Math.min( possible, itemsToMove );
|
|
injectable.setStackSize( possible );
|
|
|
|
final IAEStack extracted = src.extractItems( injectable, Actionable.MODULATE, this.mySrc );
|
|
if( extracted != null )
|
|
{
|
|
possible = extracted.getStackSize();
|
|
extracted.setCraftable( false );
|
|
final IAEStack failed = Platform.poweredInsert( energy, destination, extracted, this.mySrc );
|
|
|
|
if( failed != null )
|
|
{
|
|
possible -= failed.getStackSize();
|
|
src.injectItems( failed, Actionable.MODULATE, this.mySrc );
|
|
}
|
|
|
|
if( possible > 0 )
|
|
{
|
|
itemsToMove -= possible;
|
|
didStuff = true;
|
|
}
|
|
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
while( itemsToMove > 0 && didStuff );
|
|
|
|
return itemsToMove / chan.transferFactor();
|
|
}
|
|
|
|
private boolean shouldMove( final IMEInventory<?> inv )
|
|
{
|
|
final FullnessMode fm = (FullnessMode) this.manager.getSetting( Settings.FULLNESS_MODE );
|
|
|
|
if( inv != null )
|
|
{
|
|
return this.matches( fm, inv );
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
private boolean moveSlot( final int x )
|
|
{
|
|
final InventoryAdaptor ad = new AdaptorItemHandler( this.outputCells );
|
|
if( ad.addItems( this.inputCells.getStackInSlot( x ) ).isEmpty() )
|
|
{
|
|
this.inputCells.setStackInSlot( x, ItemStack.EMPTY );
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
private boolean matches( final FullnessMode fm, final IMEInventory src )
|
|
{
|
|
if( fm == FullnessMode.HALF )
|
|
{
|
|
return true;
|
|
}
|
|
|
|
final IItemList<? extends IAEStack> myList;
|
|
|
|
if( src instanceof IMEMonitor )
|
|
{
|
|
myList = ( (IMEMonitor) src ).getStorageList();
|
|
}
|
|
else
|
|
{
|
|
myList = src.getAvailableItems( src.getChannel().createList() );
|
|
}
|
|
|
|
if( fm == FullnessMode.EMPTY )
|
|
{
|
|
return myList.isEmpty();
|
|
}
|
|
|
|
final IAEStack test = myList.getFirstItem();
|
|
if( test != null )
|
|
{
|
|
IAEStack testCopy = test.copy();
|
|
testCopy.setStackSize( 1 );
|
|
return src.injectItems( testCopy, Actionable.SIMULATE, this.mySrc ) != null;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Adds the items in the upgrade slots to the drop list.
|
|
*
|
|
* @param w world
|
|
* @param x x pos of tile entity
|
|
* @param y y pos of tile entity
|
|
* @param z z pos of tile entity
|
|
* @param drops drops of tile entity
|
|
*/
|
|
@Override
|
|
public void getDrops( final World w, final BlockPos pos, final List<ItemStack> drops )
|
|
{
|
|
super.getDrops( w, pos, drops );
|
|
|
|
for( int upgradeIndex = 0; upgradeIndex < this.upgrades.getSlots(); upgradeIndex++ )
|
|
{
|
|
final ItemStack stackInSlot = this.upgrades.getStackInSlot( upgradeIndex );
|
|
|
|
if( !stackInSlot.isEmpty() )
|
|
{
|
|
drops.add( stackInSlot );
|
|
}
|
|
}
|
|
}
|
|
}
|