thatsIch
3783ae8619
Many exceptions got an improvement due to changed class or description or details it is providing. Is not complete, needs to be done in patches in the regions, where it is needed, since some are just swallowed. Removed total usage of pure RuntimeExceptions to 0.
1123 lines
28 KiB
Java
1123 lines
28 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.container;
|
|
|
|
|
|
import java.io.ByteArrayInputStream;
|
|
import java.io.ByteArrayOutputStream;
|
|
import java.io.IOException;
|
|
import java.lang.reflect.Field;
|
|
import java.util.ArrayList;
|
|
import java.util.HashMap;
|
|
import java.util.HashSet;
|
|
import java.util.LinkedList;
|
|
import java.util.List;
|
|
|
|
import net.minecraft.entity.player.EntityPlayer;
|
|
import net.minecraft.entity.player.EntityPlayerMP;
|
|
import net.minecraft.entity.player.InventoryPlayer;
|
|
import net.minecraft.inventory.Container;
|
|
import net.minecraft.inventory.ICrafting;
|
|
import net.minecraft.inventory.IInventory;
|
|
import net.minecraft.inventory.Slot;
|
|
import net.minecraft.item.ItemStack;
|
|
import net.minecraft.nbt.CompressedStreamTools;
|
|
import net.minecraft.nbt.NBTTagCompound;
|
|
import net.minecraft.tileentity.TileEntity;
|
|
import net.minecraftforge.common.util.ForgeDirection;
|
|
|
|
import appeng.api.AEApi;
|
|
import appeng.api.config.Actionable;
|
|
import appeng.api.config.SecurityPermissions;
|
|
import appeng.api.implementations.guiobjects.IGuiItemObject;
|
|
import appeng.api.networking.IGrid;
|
|
import appeng.api.networking.IGridNode;
|
|
import appeng.api.networking.energy.IEnergyGrid;
|
|
import appeng.api.networking.energy.IEnergySource;
|
|
import appeng.api.networking.security.BaseActionSource;
|
|
import appeng.api.networking.security.IActionHost;
|
|
import appeng.api.networking.security.ISecurityGrid;
|
|
import appeng.api.networking.security.PlayerSource;
|
|
import appeng.api.parts.IPart;
|
|
import appeng.api.storage.IMEInventoryHandler;
|
|
import appeng.api.storage.data.IAEItemStack;
|
|
import appeng.client.me.InternalSlotME;
|
|
import appeng.client.me.SlotME;
|
|
import appeng.container.guisync.GuiSync;
|
|
import appeng.container.guisync.SyncData;
|
|
import appeng.container.slot.AppEngSlot;
|
|
import appeng.container.slot.SlotCraftingMatrix;
|
|
import appeng.container.slot.SlotCraftingTerm;
|
|
import appeng.container.slot.SlotDisabled;
|
|
import appeng.container.slot.SlotFake;
|
|
import appeng.container.slot.SlotInaccessible;
|
|
import appeng.container.slot.SlotPlayerHotBar;
|
|
import appeng.container.slot.SlotPlayerInv;
|
|
import appeng.core.AELog;
|
|
import appeng.core.sync.network.NetworkHandler;
|
|
import appeng.core.sync.packets.PacketInventoryAction;
|
|
import appeng.core.sync.packets.PacketPartialItem;
|
|
import appeng.core.sync.packets.PacketValueConfig;
|
|
import appeng.helpers.ICustomNameObject;
|
|
import appeng.helpers.InventoryAction;
|
|
import appeng.util.InventoryAdaptor;
|
|
import appeng.util.Platform;
|
|
import appeng.util.inv.AdaptorPlayerHand;
|
|
import appeng.util.item.AEItemStack;
|
|
|
|
|
|
public abstract class AEBaseContainer extends Container
|
|
{
|
|
|
|
protected final InventoryPlayer invPlayer;
|
|
protected final BaseActionSource mySrc;
|
|
protected final HashSet<Integer> locked = new HashSet<Integer>();
|
|
final TileEntity tileEntity;
|
|
final IPart part;
|
|
final IGuiItemObject obj;
|
|
final List<PacketPartialItem> dataChunks = new LinkedList<PacketPartialItem>();
|
|
final HashMap<Integer, SyncData> syncData = new HashMap<Integer, SyncData>();
|
|
public boolean isContainerValid = true;
|
|
public String customName;
|
|
public ContainerOpenContext openContext;
|
|
protected IMEInventoryHandler<IAEItemStack> cellInv;
|
|
protected IEnergySource powerSrc;
|
|
boolean sentCustomName;
|
|
int ticksSinceCheck = 900;
|
|
IAEItemStack clientRequestedTargetItem = null;
|
|
|
|
public AEBaseContainer( InventoryPlayer ip, TileEntity myTile, IPart myPart )
|
|
{
|
|
this( ip, myTile, myPart, null );
|
|
}
|
|
|
|
public AEBaseContainer( InventoryPlayer ip, TileEntity myTile, IPart myPart, IGuiItemObject gio )
|
|
{
|
|
this.invPlayer = ip;
|
|
this.tileEntity = myTile;
|
|
this.part = myPart;
|
|
this.obj = gio;
|
|
this.mySrc = new PlayerSource( ip.player, this.getActionHost() );
|
|
this.prepareSync();
|
|
}
|
|
|
|
protected IActionHost getActionHost()
|
|
{
|
|
if( this.obj instanceof IActionHost )
|
|
return (IActionHost) this.obj;
|
|
|
|
if( this.tileEntity instanceof IActionHost )
|
|
return (IActionHost) this.tileEntity;
|
|
|
|
if( this.part instanceof IActionHost )
|
|
return (IActionHost) this.part;
|
|
|
|
return null;
|
|
}
|
|
|
|
private void prepareSync()
|
|
{
|
|
for( Field f : this.getClass().getFields() )
|
|
{
|
|
if( f.isAnnotationPresent( GuiSync.class ) )
|
|
{
|
|
GuiSync annotation = f.getAnnotation( GuiSync.class );
|
|
if( this.syncData.containsKey( annotation.value() ) )
|
|
AELog.warning( "Channel already in use: " + annotation.value() + " for " + f.getName() );
|
|
else
|
|
this.syncData.put( annotation.value(), new SyncData( this, f, annotation ) );
|
|
}
|
|
}
|
|
}
|
|
|
|
public AEBaseContainer( InventoryPlayer ip, Object anchor )
|
|
{
|
|
this.invPlayer = ip;
|
|
this.tileEntity = anchor instanceof TileEntity ? (TileEntity) anchor : null;
|
|
this.part = anchor instanceof IPart ? (IPart) anchor : null;
|
|
this.obj = anchor instanceof IGuiItemObject ? (IGuiItemObject) anchor : null;
|
|
|
|
if( this.tileEntity == null && this.part == null && this.obj == null )
|
|
throw new IllegalArgumentException( "Must have a valid anchor, instead " + anchor + " in " + ip );
|
|
|
|
this.mySrc = new PlayerSource( ip.player, this.getActionHost() );
|
|
|
|
this.prepareSync();
|
|
}
|
|
|
|
public void postPartial( PacketPartialItem packetPartialItem )
|
|
{
|
|
this.dataChunks.add( packetPartialItem );
|
|
if( packetPartialItem.getPageCount() == this.dataChunks.size() )
|
|
this.parsePartials();
|
|
}
|
|
|
|
private void parsePartials()
|
|
{
|
|
int total = 0;
|
|
for( PacketPartialItem ppi : this.dataChunks )
|
|
total += ppi.getSize();
|
|
|
|
byte[] buffer = new byte[total];
|
|
int cursor = 0;
|
|
|
|
for( PacketPartialItem ppi : this.dataChunks )
|
|
cursor = ppi.write( buffer, cursor );
|
|
|
|
try
|
|
{
|
|
NBTTagCompound data = CompressedStreamTools.readCompressed( new ByteArrayInputStream( buffer ) );
|
|
if( data != null )
|
|
this.setTargetStack( AEApi.instance().storage().createItemStack( ItemStack.loadItemStackFromNBT( data ) ) );
|
|
}
|
|
catch( IOException e )
|
|
{
|
|
AELog.error( e );
|
|
}
|
|
|
|
this.dataChunks.clear();
|
|
}
|
|
|
|
public IAEItemStack getTargetStack()
|
|
{
|
|
return this.clientRequestedTargetItem;
|
|
}
|
|
|
|
public void setTargetStack( IAEItemStack stack )
|
|
{
|
|
// client doesn't need to re-send, makes for lower overhead rapid packets.
|
|
if( Platform.isClient() )
|
|
{
|
|
ItemStack a = stack == null ? null : stack.getItemStack();
|
|
ItemStack b = this.clientRequestedTargetItem == null ? null : this.clientRequestedTargetItem.getItemStack();
|
|
|
|
if( Platform.isSameItemPrecise( a, b ) )
|
|
return;
|
|
|
|
ByteArrayOutputStream stream = new ByteArrayOutputStream();
|
|
NBTTagCompound item = new NBTTagCompound();
|
|
|
|
if( stack != null )
|
|
stack.writeToNBT( item );
|
|
|
|
try
|
|
{
|
|
CompressedStreamTools.writeCompressed( item, stream );
|
|
|
|
int maxChunkSize = 30000;
|
|
List<byte[]> miniPackets = new LinkedList<byte[]>();
|
|
|
|
byte[] data = stream.toByteArray();
|
|
|
|
ByteArrayInputStream bis = new ByteArrayInputStream( data, 0, stream.size() );
|
|
while( bis.available() > 0 )
|
|
{
|
|
int nextBLock = bis.available() > maxChunkSize ? maxChunkSize : bis.available();
|
|
byte[] nextSegment = new byte[nextBLock];
|
|
bis.read( nextSegment );
|
|
miniPackets.add( nextSegment );
|
|
}
|
|
bis.close();
|
|
stream.close();
|
|
|
|
int page = 0;
|
|
for( byte[] packet : miniPackets )
|
|
{
|
|
PacketPartialItem ppi = new PacketPartialItem( page, miniPackets.size(), packet );
|
|
page++;
|
|
NetworkHandler.instance.sendToServer( ppi );
|
|
}
|
|
}
|
|
catch( IOException e )
|
|
{
|
|
AELog.error( e );
|
|
return;
|
|
}
|
|
}
|
|
|
|
this.clientRequestedTargetItem = stack == null ? null : stack.copy();
|
|
}
|
|
|
|
public BaseActionSource getSource()
|
|
{
|
|
return this.mySrc;
|
|
}
|
|
|
|
public void verifyPermissions( SecurityPermissions security, boolean requirePower )
|
|
{
|
|
if( Platform.isClient() )
|
|
return;
|
|
|
|
this.ticksSinceCheck++;
|
|
if( this.ticksSinceCheck < 20 )
|
|
return;
|
|
|
|
this.ticksSinceCheck = 0;
|
|
this.isContainerValid = this.isContainerValid && this.hasAccess( security, requirePower );
|
|
}
|
|
|
|
protected boolean hasAccess( SecurityPermissions perm, boolean requirePower )
|
|
{
|
|
IActionHost host = this.getActionHost();
|
|
|
|
if( host != null )
|
|
{
|
|
IGridNode gn = host.getActionableNode();
|
|
if( gn != null )
|
|
{
|
|
IGrid g = gn.getGrid();
|
|
if( g != null )
|
|
{
|
|
if( requirePower )
|
|
{
|
|
IEnergyGrid eg = g.getCache( IEnergyGrid.class );
|
|
if( !eg.isNetworkPowered() )
|
|
return false;
|
|
}
|
|
|
|
ISecurityGrid sg = g.getCache( ISecurityGrid.class );
|
|
if( sg.hasPermission( this.invPlayer.player, perm ) )
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
public void lockPlayerInventorySlot( int idx )
|
|
{
|
|
this.locked.add( idx );
|
|
}
|
|
|
|
public Object getTarget()
|
|
{
|
|
if( this.tileEntity != null )
|
|
return this.tileEntity;
|
|
if( this.part != null )
|
|
return this.part;
|
|
if( this.obj != null )
|
|
return this.obj;
|
|
return null;
|
|
}
|
|
|
|
public InventoryPlayer getPlayerInv()
|
|
{
|
|
return this.invPlayer;
|
|
}
|
|
|
|
public TileEntity getTileEntity()
|
|
{
|
|
return this.tileEntity;
|
|
}
|
|
|
|
public final void updateFullProgressBar( int idx, long value )
|
|
{
|
|
if( this.syncData.containsKey( idx ) )
|
|
{
|
|
this.syncData.get( idx ).update( value );
|
|
return;
|
|
}
|
|
|
|
this.updateProgressBar( idx, (int) value );
|
|
}
|
|
|
|
public void stringSync( int idx, String value )
|
|
{
|
|
if( this.syncData.containsKey( idx ) )
|
|
{
|
|
this.syncData.get( idx ).update( value );
|
|
}
|
|
}
|
|
|
|
protected void bindPlayerInventory( InventoryPlayer inventoryPlayer, int offset_x, int offset_y )
|
|
{
|
|
// bind player inventory
|
|
for( int i = 0; i < 3; i++ )
|
|
{
|
|
for( int j = 0; j < 9; j++ )
|
|
{
|
|
if( this.locked.contains( j + i * 9 + 9 ) )
|
|
this.addSlotToContainer( new SlotDisabled( inventoryPlayer, j + i * 9 + 9, 8 + j * 18 + offset_x, offset_y + i * 18 ) );
|
|
else
|
|
this.addSlotToContainer( new SlotPlayerInv( inventoryPlayer, j + i * 9 + 9, 8 + j * 18 + offset_x, offset_y + i * 18 ) );
|
|
}
|
|
}
|
|
|
|
// bind player hotbar
|
|
for( int i = 0; i < 9; i++ )
|
|
{
|
|
if( this.locked.contains( i ) )
|
|
this.addSlotToContainer( new SlotDisabled( inventoryPlayer, i, 8 + i * 18 + offset_x, 58 + offset_y ) );
|
|
else
|
|
this.addSlotToContainer( new SlotPlayerHotBar( inventoryPlayer, i, 8 + i * 18 + offset_x, 58 + offset_y ) );
|
|
}
|
|
}
|
|
|
|
@Override
|
|
protected Slot addSlotToContainer( Slot newSlot )
|
|
{
|
|
if( newSlot instanceof AppEngSlot )
|
|
{
|
|
AppEngSlot s = (AppEngSlot) newSlot;
|
|
s.myContainer = this;
|
|
return super.addSlotToContainer( newSlot );
|
|
}
|
|
else
|
|
throw new IllegalArgumentException( "Invalid Slot [" + newSlot + "]for AE Container instead of AppEngSlot." );
|
|
}
|
|
|
|
@Override
|
|
public void detectAndSendChanges()
|
|
{
|
|
this.sendCustomName();
|
|
|
|
if( Platform.isServer() )
|
|
{
|
|
for( Object crafter : this.crafters )
|
|
{
|
|
ICrafting icrafting = (ICrafting) crafter;
|
|
|
|
for( SyncData sd : this.syncData.values() )
|
|
sd.tick( icrafting );
|
|
}
|
|
}
|
|
|
|
super.detectAndSendChanges();
|
|
}
|
|
|
|
@Override
|
|
public ItemStack transferStackInSlot( EntityPlayer p, int idx )
|
|
{
|
|
if( Platform.isClient() )
|
|
return null;
|
|
|
|
boolean hasMETiles = false;
|
|
for( Object is : this.inventorySlots )
|
|
{
|
|
if( is instanceof InternalSlotME )
|
|
{
|
|
hasMETiles = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if( hasMETiles && Platform.isClient() )
|
|
{
|
|
return null;
|
|
}
|
|
|
|
ItemStack tis = null;
|
|
AppEngSlot clickSlot = (AppEngSlot) this.inventorySlots.get( idx ); // require AE SLots!
|
|
|
|
if( clickSlot instanceof SlotDisabled || clickSlot instanceof SlotInaccessible )
|
|
return null;
|
|
if( clickSlot != null && clickSlot.getHasStack() )
|
|
{
|
|
tis = clickSlot.getStack();
|
|
|
|
if( tis == null )
|
|
return null;
|
|
|
|
List<Slot> selectedSlots = new ArrayList<Slot>();
|
|
|
|
/**
|
|
* Gather a list of valid destinations.
|
|
*/
|
|
if( clickSlot.isPlayerSide() )
|
|
{
|
|
tis = this.shiftStoreItem( tis );
|
|
|
|
// target slots in the container...
|
|
for( Object inventorySlot : this.inventorySlots )
|
|
{
|
|
AppEngSlot cs = (AppEngSlot) inventorySlot;
|
|
|
|
if( !( cs.isPlayerSide() ) && !( cs instanceof SlotFake ) && !( cs instanceof SlotCraftingMatrix ) )
|
|
{
|
|
if( cs.isItemValid( tis ) )
|
|
{
|
|
selectedSlots.add( cs );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// target slots in the container...
|
|
for( Object inventorySlot : this.inventorySlots )
|
|
{
|
|
AppEngSlot cs = (AppEngSlot) inventorySlot;
|
|
|
|
if( ( cs.isPlayerSide() ) && !( cs instanceof SlotFake ) && !( cs instanceof SlotCraftingMatrix ) )
|
|
{
|
|
if( cs.isItemValid( tis ) )
|
|
{
|
|
selectedSlots.add( cs );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Handle Fake Slot Shift clicking.
|
|
*/
|
|
if( selectedSlots.isEmpty() && clickSlot.isPlayerSide() )
|
|
{
|
|
if( tis != null )
|
|
{
|
|
// target slots in the container...
|
|
for( Object inventorySlot : this.inventorySlots )
|
|
{
|
|
AppEngSlot cs = (AppEngSlot) inventorySlot;
|
|
ItemStack destination = cs.getStack();
|
|
|
|
if( !( cs.isPlayerSide() ) && cs instanceof SlotFake )
|
|
{
|
|
if( Platform.isSameItemPrecise( destination, tis ) )
|
|
{
|
|
return null;
|
|
}
|
|
else if( destination == null )
|
|
{
|
|
cs.putStack( tis.copy() );
|
|
cs.onSlotChanged();
|
|
this.updateSlot( cs );
|
|
return null;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if( tis != null )
|
|
{
|
|
// find partials..
|
|
for( Slot d : selectedSlots )
|
|
{
|
|
if( d instanceof SlotDisabled || d instanceof SlotME )
|
|
continue;
|
|
|
|
if( d.isItemValid( tis ) )
|
|
{
|
|
if( d.getHasStack() )
|
|
{
|
|
ItemStack t = d.getStack();
|
|
|
|
if( Platform.isSameItemPrecise( tis, t ) ) // t.isItemEqual(tis))
|
|
{
|
|
int maxSize = t.getMaxStackSize();
|
|
if( maxSize > d.getSlotStackLimit() )
|
|
maxSize = d.getSlotStackLimit();
|
|
|
|
int placeAble = maxSize - t.stackSize;
|
|
|
|
if( tis.stackSize < placeAble )
|
|
{
|
|
placeAble = tis.stackSize;
|
|
}
|
|
|
|
t.stackSize += placeAble;
|
|
tis.stackSize -= placeAble;
|
|
|
|
if( tis.stackSize <= 0 )
|
|
{
|
|
clickSlot.putStack( null );
|
|
d.onSlotChanged();
|
|
|
|
// if ( hasMETiles ) updateClient();
|
|
|
|
this.updateSlot( clickSlot );
|
|
this.updateSlot( d );
|
|
return null;
|
|
}
|
|
else
|
|
this.updateSlot( d );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// any match..
|
|
for( Slot d : selectedSlots )
|
|
{
|
|
if( d instanceof SlotDisabled || d instanceof SlotME )
|
|
continue;
|
|
|
|
if( d.isItemValid( tis ) )
|
|
{
|
|
if( d.getHasStack() )
|
|
{
|
|
ItemStack t = d.getStack();
|
|
|
|
if( Platform.isSameItemPrecise( t, tis ) )
|
|
{
|
|
int maxSize = t.getMaxStackSize();
|
|
if( d.getSlotStackLimit() < maxSize )
|
|
maxSize = d.getSlotStackLimit();
|
|
|
|
int placeAble = maxSize - t.stackSize;
|
|
|
|
if( tis.stackSize < placeAble )
|
|
{
|
|
placeAble = tis.stackSize;
|
|
}
|
|
|
|
t.stackSize += placeAble;
|
|
tis.stackSize -= placeAble;
|
|
|
|
if( tis.stackSize <= 0 )
|
|
{
|
|
clickSlot.putStack( null );
|
|
d.onSlotChanged();
|
|
|
|
// if ( worldEntity != null )
|
|
// worldEntity.markDirty();
|
|
// if ( hasMETiles ) updateClient();
|
|
|
|
this.updateSlot( clickSlot );
|
|
this.updateSlot( d );
|
|
return null;
|
|
}
|
|
else
|
|
this.updateSlot( d );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
int maxSize = tis.getMaxStackSize();
|
|
if( maxSize > d.getSlotStackLimit() )
|
|
maxSize = d.getSlotStackLimit();
|
|
|
|
ItemStack tmp = tis.copy();
|
|
if( tmp.stackSize > maxSize )
|
|
tmp.stackSize = maxSize;
|
|
|
|
tis.stackSize -= tmp.stackSize;
|
|
d.putStack( tmp );
|
|
|
|
if( tis.stackSize <= 0 )
|
|
{
|
|
clickSlot.putStack( null );
|
|
d.onSlotChanged();
|
|
|
|
// if ( worldEntity != null )
|
|
// worldEntity.markDirty();
|
|
// if ( hasMETiles ) updateClient();
|
|
|
|
this.updateSlot( clickSlot );
|
|
this.updateSlot( d );
|
|
return null;
|
|
}
|
|
else
|
|
this.updateSlot( d );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
clickSlot.putStack( tis != null ? tis.copy() : null );
|
|
}
|
|
|
|
this.updateSlot( clickSlot );
|
|
return null;
|
|
}
|
|
|
|
@Override
|
|
public final void updateProgressBar( int idx, int value )
|
|
{
|
|
if( this.syncData.containsKey( idx ) )
|
|
{
|
|
this.syncData.get( idx ).update( (long) value );
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public boolean canInteractWith( EntityPlayer entityplayer )
|
|
{
|
|
if( this.isContainerValid )
|
|
{
|
|
if( this.tileEntity instanceof IInventory )
|
|
return ( (IInventory) this.tileEntity ).isUseableByPlayer( entityplayer );
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
@Override
|
|
public boolean canDragIntoSlot( Slot s )
|
|
{
|
|
return ( (AppEngSlot) s ).isDraggable;
|
|
}
|
|
|
|
public void doAction( EntityPlayerMP player, InventoryAction action, int slot, long id )
|
|
{
|
|
if( slot >= 0 && slot < this.inventorySlots.size() )
|
|
{
|
|
Slot s = this.getSlot( slot );
|
|
|
|
if( s instanceof SlotCraftingTerm )
|
|
{
|
|
switch( action )
|
|
{
|
|
case CRAFT_SHIFT:
|
|
case CRAFT_ITEM:
|
|
case CRAFT_STACK:
|
|
( (SlotCraftingTerm) s ).doClick( action, player );
|
|
this.updateHeld( player );
|
|
default:
|
|
}
|
|
}
|
|
|
|
if( s instanceof SlotFake )
|
|
{
|
|
ItemStack hand = player.inventory.getItemStack();
|
|
|
|
switch( action )
|
|
{
|
|
case PICKUP_OR_SET_DOWN:
|
|
|
|
if( hand == null )
|
|
s.putStack( null );
|
|
else
|
|
s.putStack( hand.copy() );
|
|
|
|
break;
|
|
case PLACE_SINGLE:
|
|
|
|
if( hand != null )
|
|
{
|
|
ItemStack is = hand.copy();
|
|
is.stackSize = 1;
|
|
s.putStack( is );
|
|
}
|
|
|
|
break;
|
|
case SPLIT_OR_PLACE_SINGLE:
|
|
|
|
ItemStack is = s.getStack();
|
|
if( is != null )
|
|
{
|
|
if( hand == null )
|
|
is.stackSize--;
|
|
else if( hand.isItemEqual( is ) )
|
|
is.stackSize = Math.min( is.getMaxStackSize(), is.stackSize + 1 );
|
|
else
|
|
{
|
|
is = hand.copy();
|
|
is.stackSize = 1;
|
|
}
|
|
|
|
s.putStack( is );
|
|
}
|
|
else if( hand != null )
|
|
{
|
|
is = hand.copy();
|
|
is.stackSize = 1;
|
|
s.putStack( is );
|
|
}
|
|
|
|
break;
|
|
case CREATIVE_DUPLICATE:
|
|
case MOVE_REGION:
|
|
case SHIFT_CLICK:
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
if( action == InventoryAction.MOVE_REGION )
|
|
{
|
|
List<Slot> from = new LinkedList<Slot>();
|
|
|
|
for( Object j : this.inventorySlots )
|
|
{
|
|
if( j instanceof Slot && j.getClass() == s.getClass() )
|
|
from.add( (Slot) j );
|
|
}
|
|
|
|
for( Slot fr : from )
|
|
this.transferStackInSlot( player, fr.slotNumber );
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
// get target item.
|
|
IAEItemStack slotItem = this.clientRequestedTargetItem;
|
|
|
|
switch( action )
|
|
{
|
|
case SHIFT_CLICK:
|
|
if( this.powerSrc == null || this.cellInv == null )
|
|
return;
|
|
|
|
if( slotItem != null )
|
|
{
|
|
IAEItemStack ais = slotItem.copy();
|
|
ItemStack myItem = ais.getItemStack();
|
|
|
|
ais.setStackSize( myItem.getMaxStackSize() );
|
|
|
|
InventoryAdaptor adp = InventoryAdaptor.getAdaptor( player, ForgeDirection.UNKNOWN );
|
|
myItem.stackSize = (int) ais.getStackSize();
|
|
myItem = adp.simulateAdd( myItem );
|
|
|
|
if( myItem != null )
|
|
ais.setStackSize( ais.getStackSize() - myItem.stackSize );
|
|
|
|
ais = Platform.poweredExtraction( this.powerSrc, this.cellInv, ais, this.mySrc );
|
|
if( ais != null )
|
|
adp.addItems( ais.getItemStack() );
|
|
}
|
|
break;
|
|
case ROLL_DOWN:
|
|
if( this.powerSrc == null || this.cellInv == null )
|
|
return;
|
|
|
|
int releaseQty = 1;
|
|
ItemStack isg = player.inventory.getItemStack();
|
|
|
|
if( isg != null && releaseQty > 0 )
|
|
{
|
|
IAEItemStack ais = AEApi.instance().storage().createItemStack( isg );
|
|
ais.setStackSize( 1 );
|
|
IAEItemStack extracted = ais.copy();
|
|
|
|
ais = Platform.poweredInsert( this.powerSrc, this.cellInv, ais, this.mySrc );
|
|
if( ais == null )
|
|
{
|
|
InventoryAdaptor ia = new AdaptorPlayerHand( player );
|
|
|
|
ItemStack fail = ia.removeItems( 1, extracted.getItemStack(), null );
|
|
if( fail == null )
|
|
this.cellInv.extractItems( extracted, Actionable.MODULATE, this.mySrc );
|
|
|
|
this.updateHeld( player );
|
|
}
|
|
}
|
|
|
|
break;
|
|
case ROLL_UP:
|
|
case PICKUP_SINGLE:
|
|
if( this.powerSrc == null || this.cellInv == null )
|
|
return;
|
|
|
|
if( slotItem != null )
|
|
{
|
|
int liftQty = 1;
|
|
ItemStack item = player.inventory.getItemStack();
|
|
|
|
if( item != null )
|
|
{
|
|
if( item.stackSize >= item.getMaxStackSize() )
|
|
liftQty = 0;
|
|
if( !Platform.isSameItemPrecise( slotItem.getItemStack(), item ) )
|
|
liftQty = 0;
|
|
}
|
|
|
|
if( liftQty > 0 )
|
|
{
|
|
IAEItemStack ais = slotItem.copy();
|
|
ais.setStackSize( 1 );
|
|
ais = Platform.poweredExtraction( this.powerSrc, this.cellInv, ais, this.mySrc );
|
|
if( ais != null )
|
|
{
|
|
InventoryAdaptor ia = new AdaptorPlayerHand( player );
|
|
|
|
ItemStack fail = ia.addItems( ais.getItemStack() );
|
|
if( fail != null )
|
|
this.cellInv.injectItems( ais, Actionable.MODULATE, this.mySrc );
|
|
|
|
this.updateHeld( player );
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
case PICKUP_OR_SET_DOWN:
|
|
if( this.powerSrc == null || this.cellInv == null )
|
|
return;
|
|
|
|
if( player.inventory.getItemStack() == null )
|
|
{
|
|
if( slotItem != null )
|
|
{
|
|
IAEItemStack ais = slotItem.copy();
|
|
ais.setStackSize( ais.getItemStack().getMaxStackSize() );
|
|
ais = Platform.poweredExtraction( this.powerSrc, this.cellInv, ais, this.mySrc );
|
|
if( ais != null )
|
|
player.inventory.setItemStack( ais.getItemStack() );
|
|
else
|
|
player.inventory.setItemStack( null );
|
|
this.updateHeld( player );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
IAEItemStack ais = AEApi.instance().storage().createItemStack( player.inventory.getItemStack() );
|
|
ais = Platform.poweredInsert( this.powerSrc, this.cellInv, ais, this.mySrc );
|
|
if( ais != null )
|
|
player.inventory.setItemStack( ais.getItemStack() );
|
|
else
|
|
player.inventory.setItemStack( null );
|
|
this.updateHeld( player );
|
|
}
|
|
|
|
break;
|
|
case SPLIT_OR_PLACE_SINGLE:
|
|
if( this.powerSrc == null || this.cellInv == null )
|
|
return;
|
|
|
|
if( player.inventory.getItemStack() == null )
|
|
{
|
|
if( slotItem != null )
|
|
{
|
|
IAEItemStack ais = slotItem.copy();
|
|
long maxSize = ais.getItemStack().getMaxStackSize();
|
|
ais.setStackSize( maxSize );
|
|
ais = this.cellInv.extractItems( ais, Actionable.SIMULATE, this.mySrc );
|
|
|
|
if( ais != null )
|
|
{
|
|
long stackSize = Math.min( maxSize, ais.getStackSize() );
|
|
ais.setStackSize( ( stackSize + 1 ) >> 1 );
|
|
ais = Platform.poweredExtraction( this.powerSrc, this.cellInv, ais, this.mySrc );
|
|
}
|
|
|
|
if( ais != null )
|
|
player.inventory.setItemStack( ais.getItemStack() );
|
|
else
|
|
player.inventory.setItemStack( null );
|
|
this.updateHeld( player );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
IAEItemStack ais = AEApi.instance().storage().createItemStack( player.inventory.getItemStack() );
|
|
ais.setStackSize( 1 );
|
|
ais = Platform.poweredInsert( this.powerSrc, this.cellInv, ais, this.mySrc );
|
|
if( ais == null )
|
|
{
|
|
ItemStack is = player.inventory.getItemStack();
|
|
is.stackSize--;
|
|
if( is.stackSize <= 0 )
|
|
player.inventory.setItemStack( null );
|
|
this.updateHeld( player );
|
|
}
|
|
}
|
|
|
|
break;
|
|
case CREATIVE_DUPLICATE:
|
|
if( player.capabilities.isCreativeMode && slotItem != null )
|
|
{
|
|
ItemStack is = slotItem.getItemStack();
|
|
is.stackSize = is.getMaxStackSize();
|
|
player.inventory.setItemStack( is );
|
|
this.updateHeld( player );
|
|
}
|
|
break;
|
|
case MOVE_REGION:
|
|
|
|
if( this.powerSrc == null || this.cellInv == null )
|
|
return;
|
|
|
|
if( slotItem != null )
|
|
{
|
|
int playerInv = 9 * 4;
|
|
for( int slotNum = 0; slotNum < playerInv; slotNum++ )
|
|
{
|
|
IAEItemStack ais = slotItem.copy();
|
|
ItemStack myItem = ais.getItemStack();
|
|
|
|
ais.setStackSize( myItem.getMaxStackSize() );
|
|
|
|
InventoryAdaptor adp = InventoryAdaptor.getAdaptor( player, ForgeDirection.UNKNOWN );
|
|
myItem.stackSize = (int) ais.getStackSize();
|
|
myItem = adp.simulateAdd( myItem );
|
|
|
|
if( myItem != null )
|
|
ais.setStackSize( ais.getStackSize() - myItem.stackSize );
|
|
|
|
ais = Platform.poweredExtraction( this.powerSrc, this.cellInv, ais, this.mySrc );
|
|
if( ais != null )
|
|
adp.addItems( ais.getItemStack() );
|
|
else
|
|
return;
|
|
}
|
|
}
|
|
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
protected void updateHeld( EntityPlayerMP p )
|
|
{
|
|
if( Platform.isServer() )
|
|
{
|
|
try
|
|
{
|
|
NetworkHandler.instance.sendTo( new PacketInventoryAction( InventoryAction.UPDATE_HAND, 0, AEItemStack.create( p.inventory.getItemStack() ) ), p );
|
|
}
|
|
catch( IOException e )
|
|
{
|
|
AELog.error( e );
|
|
}
|
|
}
|
|
}
|
|
|
|
public ItemStack shiftStoreItem( ItemStack input )
|
|
{
|
|
if( this.powerSrc == null || this.cellInv == null )
|
|
return input;
|
|
IAEItemStack ais = Platform.poweredInsert( this.powerSrc, this.cellInv, AEApi.instance().storage().createItemStack( input ), this.mySrc );
|
|
if( ais == null )
|
|
return null;
|
|
return ais.getItemStack();
|
|
}
|
|
|
|
private void updateSlot( Slot clickSlot )
|
|
{
|
|
// ???
|
|
this.detectAndSendChanges();
|
|
}
|
|
|
|
protected void sendCustomName()
|
|
{
|
|
if( !this.sentCustomName )
|
|
{
|
|
this.sentCustomName = true;
|
|
if( Platform.isServer() )
|
|
{
|
|
ICustomNameObject name = null;
|
|
|
|
if( this.part instanceof ICustomNameObject )
|
|
name = (ICustomNameObject) this.part;
|
|
|
|
if( this.tileEntity instanceof ICustomNameObject )
|
|
name = (ICustomNameObject) this.tileEntity;
|
|
|
|
if( this.obj instanceof ICustomNameObject )
|
|
name = (ICustomNameObject) this.obj;
|
|
|
|
if( this instanceof ICustomNameObject )
|
|
name = (ICustomNameObject) this;
|
|
|
|
if( name != null )
|
|
{
|
|
if( name.hasCustomName() )
|
|
this.customName = name.getCustomName();
|
|
|
|
if( this.customName != null )
|
|
{
|
|
try
|
|
{
|
|
NetworkHandler.instance.sendTo( new PacketValueConfig( "CustomName", this.customName ), (EntityPlayerMP) this.invPlayer.player );
|
|
}
|
|
catch( IOException e )
|
|
{
|
|
AELog.error( e );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public void swapSlotContents( int slotA, int slotB )
|
|
{
|
|
Slot a = this.getSlot( slotA );
|
|
Slot b = this.getSlot( slotB );
|
|
|
|
// NPE protection...
|
|
if( a == null || b == null )
|
|
return;
|
|
|
|
ItemStack isA = a.getStack();
|
|
ItemStack isB = b.getStack();
|
|
|
|
// something to do?
|
|
if( isA == null && isB == null )
|
|
return;
|
|
|
|
// can take?
|
|
|
|
if( isA != null && !a.canTakeStack( this.invPlayer.player ) )
|
|
return;
|
|
|
|
if( isB != null && !b.canTakeStack( this.invPlayer.player ) )
|
|
return;
|
|
|
|
// swap valid?
|
|
|
|
if( isB != null && !a.isItemValid( isB ) )
|
|
return;
|
|
|
|
if( isA != null && !b.isItemValid( isA ) )
|
|
return;
|
|
|
|
ItemStack testA = isB == null ? null : isB.copy();
|
|
ItemStack testB = isA == null ? null : isA.copy();
|
|
|
|
// can put some back?
|
|
if( testA != null && testA.stackSize > a.getSlotStackLimit() )
|
|
{
|
|
if( testB != null )
|
|
return;
|
|
|
|
int totalA = testA.stackSize;
|
|
testA.stackSize = a.getSlotStackLimit();
|
|
testB = testA.copy();
|
|
|
|
testB.stackSize = totalA - testA.stackSize;
|
|
}
|
|
|
|
if( testB != null && testB.stackSize > b.getSlotStackLimit() )
|
|
{
|
|
if( testA != null )
|
|
return;
|
|
|
|
int totalB = testB.stackSize;
|
|
testB.stackSize = b.getSlotStackLimit();
|
|
testA = testB.copy();
|
|
|
|
testA.stackSize = totalB - testA.stackSize;
|
|
}
|
|
|
|
a.putStack( testA );
|
|
b.putStack( testB );
|
|
}
|
|
|
|
public void onUpdate( String field, Object oldValue, Object newValue )
|
|
{
|
|
|
|
}
|
|
|
|
public void onSlotChange( Slot s )
|
|
{
|
|
|
|
}
|
|
|
|
public boolean isValidForSlot( Slot s, ItemStack i )
|
|
{
|
|
return true;
|
|
}
|
|
}
|