yueh
469 lines
13 KiB
Java
469 lines
13 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.ArrayList;
|
|
|
|
import net.minecraft.inventory.IInventory;
|
|
import net.minecraft.item.ItemStack;
|
|
import net.minecraft.nbt.NBTTagCompound;
|
|
import net.minecraft.world.World;
|
|
import net.minecraftforge.common.util.ForgeDirection;
|
|
|
|
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.BaseActionSource;
|
|
import appeng.api.networking.security.MachineSource;
|
|
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.StorageChannel;
|
|
import appeng.api.storage.data.IAEFluidStack;
|
|
import appeng.api.storage.data.IAEItemStack;
|
|
import appeng.api.storage.data.IAEStack;
|
|
import appeng.api.storage.data.IItemList;
|
|
import appeng.api.util.AECableType;
|
|
import appeng.api.util.DimensionalCoord;
|
|
import appeng.api.util.IConfigManager;
|
|
import appeng.core.settings.TickRates;
|
|
import appeng.me.GridAccessException;
|
|
import appeng.parts.automation.UpgradeInventory;
|
|
import appeng.tile.TileEvent;
|
|
import appeng.tile.events.TileEventType;
|
|
import appeng.tile.grid.AENetworkInvTile;
|
|
import appeng.tile.inventory.AppEngInternalInventory;
|
|
import appeng.tile.inventory.InvOperation;
|
|
import appeng.util.ConfigManager;
|
|
import appeng.util.IConfigManagerHost;
|
|
import appeng.util.InventoryAdaptor;
|
|
import appeng.util.Platform;
|
|
import appeng.util.inv.WrapperInventoryRange;
|
|
|
|
public class TileIOPort extends AENetworkInvTile implements IUpgradeableHost, IConfigManagerHost, IGridTickable
|
|
{
|
|
|
|
final ConfigManager cm = new ConfigManager( this );
|
|
|
|
final int input[] = { 0, 1, 2, 3, 4, 5 };
|
|
final int output[] = { 6, 7, 8, 9, 10, 11 };
|
|
|
|
final int outputSlots[] = { 6, 7, 8, 9, 10, 11 };
|
|
|
|
final AppEngInternalInventory cells = new AppEngInternalInventory( this, 12 );
|
|
final UpgradeInventory upgrades = new UpgradeInventory( AEApi.instance().blocks().blockIOPort.block(), this, 3 );
|
|
|
|
final BaseActionSource mySrc = new MachineSource( this );
|
|
|
|
YesNo lastRedstoneState = YesNo.UNDECIDED;
|
|
|
|
@TileEvent(TileEventType.WORLD_NBT_WRITE)
|
|
public void writeToNBT_TileIOPort(NBTTagCompound data)
|
|
{
|
|
this.cm.writeToNBT( data );
|
|
this.cells.writeToNBT( data, "cells" );
|
|
this.upgrades.writeToNBT( data, "upgrades" );
|
|
data.setInteger( "lastRedstoneState", this.lastRedstoneState.ordinal() );
|
|
}
|
|
|
|
@TileEvent(TileEventType.WORLD_NBT_READ)
|
|
public void readFromNBT_TileIOPort(NBTTagCompound data)
|
|
{
|
|
this.cm.readFromNBT( data );
|
|
this.cells.readFromNBT( data, "cells" );
|
|
this.upgrades.readFromNBT( data, "upgrades" );
|
|
if ( data.hasKey( "lastRedstoneState" ) )
|
|
this.lastRedstoneState = YesNo.values()[data.getInteger( "lastRedstoneState" )];
|
|
}
|
|
|
|
public TileIOPort() {
|
|
this.gridProxy.setFlags( GridFlags.REQUIRE_CHANNEL );
|
|
this.cm.registerSetting( Settings.REDSTONE_CONTROLLED, RedstoneMode.IGNORE );
|
|
this.cm.registerSetting( Settings.FULLNESS_MODE, FullnessMode.EMPTY );
|
|
this.cm.registerSetting( Settings.OPERATION_MODE, OperationMode.EMPTY );
|
|
}
|
|
|
|
@Override
|
|
public AECableType getCableConnectionType(ForgeDirection dir)
|
|
{
|
|
return AECableType.SMART;
|
|
}
|
|
|
|
@Override
|
|
public DimensionalCoord getLocation()
|
|
{
|
|
return new DimensionalCoord( this );
|
|
}
|
|
|
|
@Override
|
|
public IInventory getInternalInventory()
|
|
{
|
|
return this.cells;
|
|
}
|
|
|
|
@Override
|
|
public void onChangeInventory(IInventory inv, int slot, InvOperation mc, ItemStack removed, ItemStack added)
|
|
{
|
|
if ( this.cells == inv )
|
|
{
|
|
this.updateTask();
|
|
}
|
|
}
|
|
|
|
private void updateTask()
|
|
{
|
|
try
|
|
{
|
|
if ( this.hasWork() )
|
|
this.gridProxy.getTick().wakeDevice( this.gridProxy.getNode() );
|
|
else
|
|
this.gridProxy.getTick().sleepDevice( this.gridProxy.getNode() );
|
|
}
|
|
catch (GridAccessException e)
|
|
{
|
|
// :P
|
|
}
|
|
}
|
|
|
|
public void updateRedstoneState()
|
|
{
|
|
YesNo currentState = this.worldObj.isBlockIndirectlyGettingPowered( this.xCoord, this.yCoord, this.zCoord ) ? YesNo.YES : YesNo.NO;
|
|
if ( this.lastRedstoneState != currentState )
|
|
{
|
|
this.lastRedstoneState = currentState;
|
|
this.updateTask();
|
|
}
|
|
}
|
|
|
|
public 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;
|
|
|
|
RedstoneMode rs = (RedstoneMode) this.cm.getSetting( Settings.REDSTONE_CONTROLLED );
|
|
if ( rs == RedstoneMode.HIGH_SIGNAL )
|
|
return this.getRedstoneState();
|
|
return !this.getRedstoneState();
|
|
}
|
|
|
|
@Override
|
|
public int[] getAccessibleSlotsBySide(ForgeDirection d)
|
|
{
|
|
if ( d == ForgeDirection.UP || d == ForgeDirection.DOWN )
|
|
return this.input;
|
|
|
|
return this.output;
|
|
}
|
|
|
|
@Override
|
|
public IConfigManager getConfigManager()
|
|
{
|
|
return this.cm;
|
|
}
|
|
|
|
@Override
|
|
public IInventory getInventoryByName(String name)
|
|
{
|
|
if ( name.equals( "upgrades" ) )
|
|
return this.upgrades;
|
|
|
|
if ( name.equals( "cells" ) )
|
|
return this.cells;
|
|
|
|
return null;
|
|
}
|
|
|
|
@Override
|
|
public int getInstalledUpgrades(Upgrades u)
|
|
{
|
|
return this.upgrades.getInstalledUpgrades( u );
|
|
}
|
|
|
|
@Override
|
|
public void updateSetting(IConfigManager manager, Enum settingName, Enum newValue)
|
|
{
|
|
this.updateTask();
|
|
}
|
|
|
|
boolean hasWork()
|
|
{
|
|
if ( this.isEnabled() )
|
|
{
|
|
for (int x = 0; x < 6; x++)
|
|
if ( this.cells.getStackInSlot( x ) != null )
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
@Override
|
|
public TickingRequest getTickingRequest(IGridNode node)
|
|
{
|
|
return new TickingRequest( TickRates.IOPort.min, TickRates.IOPort.max, this.hasWork(), false );
|
|
}
|
|
|
|
@Override
|
|
public TickRateModulation tickingRequest(IGridNode node, int TicksSinceLastCall)
|
|
{
|
|
if ( !this.gridProxy.isActive() )
|
|
return TickRateModulation.IDLE;
|
|
|
|
long ItemsToMove = 256;
|
|
|
|
switch (this.getInstalledUpgrades( Upgrades.SPEED ))
|
|
{
|
|
case 1:
|
|
ItemsToMove *= 2;
|
|
break;
|
|
case 2:
|
|
ItemsToMove *= 4;
|
|
break;
|
|
case 3:
|
|
ItemsToMove *= 8;
|
|
break;
|
|
}
|
|
|
|
try
|
|
{
|
|
IMEInventory<IAEItemStack> itemNet = this.gridProxy.getStorage().getItemInventory();
|
|
IMEInventory<IAEFluidStack> fluidNet = this.gridProxy.getStorage().getFluidInventory();
|
|
IEnergySource energy = this.gridProxy.getEnergy();
|
|
for (int x = 0; x < 6; x++)
|
|
{
|
|
ItemStack is = this.cells.getStackInSlot( x );
|
|
if ( is != null )
|
|
{
|
|
if ( ItemsToMove > 0 )
|
|
{
|
|
IMEInventory<IAEItemStack> itemInv = this.getInv( is, StorageChannel.ITEMS );
|
|
IMEInventory<IAEFluidStack> fluidInv = this.getInv( is, StorageChannel.FLUIDS );
|
|
|
|
if ( this.cm.getSetting( Settings.OPERATION_MODE ) == OperationMode.EMPTY )
|
|
{
|
|
if ( itemInv != null )
|
|
ItemsToMove = this.transferContents( energy, itemInv, itemNet, ItemsToMove, StorageChannel.ITEMS );
|
|
if ( fluidInv != null )
|
|
ItemsToMove = this.transferContents( energy, fluidInv, fluidNet, ItemsToMove, StorageChannel.FLUIDS );
|
|
}
|
|
else
|
|
{
|
|
if ( itemInv != null )
|
|
ItemsToMove = this.transferContents( energy, itemNet, itemInv, ItemsToMove, StorageChannel.ITEMS );
|
|
if ( fluidInv != null )
|
|
ItemsToMove = this.transferContents( energy, fluidNet, fluidInv, ItemsToMove, StorageChannel.FLUIDS );
|
|
}
|
|
|
|
if ( ItemsToMove > 0 && this.shouldMove( itemInv, fluidInv ) && !this.moveSlot( x ) )
|
|
return TickRateModulation.IDLE;
|
|
|
|
return TickRateModulation.URGENT;
|
|
}
|
|
else
|
|
return TickRateModulation.URGENT;
|
|
}
|
|
}
|
|
|
|
}
|
|
catch (GridAccessException e)
|
|
{
|
|
return TickRateModulation.IDLE;
|
|
}
|
|
|
|
// nothing left to do...
|
|
return TickRateModulation.SLEEP;
|
|
}
|
|
|
|
private boolean shouldMove(IMEInventory<IAEItemStack> itemInv, IMEInventory<IAEFluidStack> fluidInv)
|
|
{
|
|
FullnessMode fm = (FullnessMode) this.cm.getSetting( Settings.FULLNESS_MODE );
|
|
|
|
if ( itemInv != null && fluidInv != null )
|
|
return this.matches( fm, itemInv ) && this.matches( fm, fluidInv );
|
|
else if ( itemInv != null )
|
|
return this.matches( fm, itemInv );
|
|
else if ( fluidInv != null )
|
|
return this.matches( fm, fluidInv );
|
|
|
|
return true;
|
|
}
|
|
|
|
private boolean matches(FullnessMode fm, IMEInventory src)
|
|
{
|
|
if ( fm == FullnessMode.HALF )
|
|
return true;
|
|
|
|
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();
|
|
|
|
IAEStack test = myList.getFirstItem();
|
|
if ( test != null )
|
|
{
|
|
test.setStackSize( 1 );
|
|
return src.injectItems( test, Actionable.SIMULATE, this.mySrc ) != null;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
ItemStack currentCell;
|
|
IMEInventory<IAEFluidStack> cachedFluid;
|
|
IMEInventory<IAEItemStack> cachedItem;
|
|
|
|
private IMEInventory getInv(ItemStack is, StorageChannel chan)
|
|
{
|
|
if ( this.currentCell != is )
|
|
{
|
|
this.currentCell = is;
|
|
this.cachedFluid = AEApi.instance().registries().cell().getCellInventory( is, null, StorageChannel.FLUIDS );
|
|
this.cachedItem = AEApi.instance().registries().cell().getCellInventory( is, null, StorageChannel.ITEMS );
|
|
}
|
|
|
|
if ( StorageChannel.ITEMS == chan )
|
|
return this.cachedItem;
|
|
|
|
return this.cachedFluid;
|
|
}
|
|
|
|
private long transferContents(IEnergySource energy, IMEInventory src, IMEInventory destination, long itemsToMove, StorageChannel chan)
|
|
{
|
|
IItemList<? extends IAEStack> myList;
|
|
if ( src instanceof IMEMonitor )
|
|
myList = ((IMEMonitor) src).getStorageList();
|
|
else
|
|
myList = src.getAvailableItems( src.getChannel().createList() );
|
|
|
|
boolean didStuff;
|
|
|
|
do
|
|
{
|
|
didStuff = false;
|
|
|
|
for (IAEStack s : myList)
|
|
{
|
|
long totalStackSize = s.getStackSize();
|
|
if ( totalStackSize > 0 )
|
|
{
|
|
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 )
|
|
{
|
|
possible = Math.min( possible, itemsToMove );
|
|
s.setStackSize( possible );
|
|
|
|
IAEStack extracted = src.extractItems( s, Actionable.MODULATE, this.mySrc );
|
|
if ( extracted != null )
|
|
{
|
|
possible = extracted.getStackSize();
|
|
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;
|
|
}
|
|
|
|
private boolean moveSlot(int x)
|
|
{
|
|
WrapperInventoryRange wir = new WrapperInventoryRange( this, this.outputSlots, true );
|
|
ItemStack result = InventoryAdaptor.getAdaptor( wir, ForgeDirection.UNKNOWN ).addItems( this.getStackInSlot( x ) );
|
|
|
|
if ( result == null )
|
|
{
|
|
this.setInventorySlotContents( x, null );
|
|
return true;
|
|
}
|
|
|
|
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( World w, int x, int y, int z, ArrayList<ItemStack> drops )
|
|
{
|
|
super.getDrops( w, x, y, z, drops );
|
|
|
|
for (int upgradeIndex = 0; upgradeIndex < this.upgrades.getSizeInventory(); upgradeIndex++)
|
|
{
|
|
ItemStack stackInSlot = this.upgrades.getStackInSlot(upgradeIndex);
|
|
|
|
if ( stackInSlot != null )
|
|
{
|
|
drops.add( stackInSlot );
|
|
}
|
|
}
|
|
}
|
|
}
|