ActuallyAdditions/src/main/java/de/ellpeck/actuallyadditions/mod/tile/TileEntityItemViewer.java

254 lines
8.8 KiB
Java
Raw Normal View History

2016-05-16 22:52:27 +02:00
/*
* This file ("TileEntityItemViewer.java") is part of the Actually Additions mod for Minecraft.
* It is created and owned by Ellpeck and distributed
* under the Actually Additions License to be found at
* http://ellpeck.de/actaddlicense
* View the source code at https://github.com/Ellpeck/ActuallyAdditions
*
2016-05-16 22:54:42 +02:00
* © 2015-2016 Ellpeck
2016-05-16 22:52:27 +02:00
*/
2016-05-08 21:09:58 +02:00
package de.ellpeck.actuallyadditions.mod.tile;
import de.ellpeck.actuallyadditions.mod.misc.LaserRelayConnectionHandler;
import de.ellpeck.actuallyadditions.mod.util.WorldUtil;
import net.minecraft.item.ItemStack;
import net.minecraft.tileentity.TileEntity;
import net.minecraft.util.EnumFacing;
import net.minecraft.util.math.BlockPos;
import net.minecraftforge.items.IItemHandler;
import java.util.ArrayList;
import java.util.Collections;
2016-05-08 21:09:58 +02:00
import java.util.List;
public class TileEntityItemViewer extends TileEntityInventoryBase{
public TileEntityItemViewer(){
super(0, "itemViewer");
}
private List<GenericItemHandlerInfo> getItemHandlerInfos(){
TileEntityLaserRelayItem relay = this.getConnectedRelay();
2016-05-08 21:09:58 +02:00
if(relay != null){
LaserRelayConnectionHandler.Network network = LaserRelayConnectionHandler.getNetworkFor(relay.getPos(), this.worldObj.provider.getDimension());
2016-05-08 21:09:58 +02:00
if(network != null){
return relay.getItemHandlersInNetwork(network);
}
}
return null;
}
private SpecificItemHandlerInfo getSwitchedIndexHandler(int i){
List<GenericItemHandlerInfo> infos = this.getItemHandlerInfos();
if(infos != null && !infos.isEmpty()){
2016-05-16 22:52:27 +02:00
Collections.sort(infos);
int currentI = 0;
if(!infos.isEmpty()){
for(GenericItemHandlerInfo info : infos){
for(IItemHandler handler : info.handlers){
int slotAmount = handler.getSlots();
if(currentI+slotAmount > i){
return new SpecificItemHandlerInfo(handler, i-currentI, info.relayInQuestion);
}
else{
currentI += slotAmount;
}
}
2016-05-08 21:09:58 +02:00
}
}
}
return null;
}
private TileEntityLaserRelayItem getConnectedRelay(){
TileEntityLaserRelayItem tileFound = null;
2016-05-08 21:09:58 +02:00
if(this.worldObj != null){ //Why is that even possible..?
for(int i = 0; i <= 5; i++){
EnumFacing side = WorldUtil.getDirectionBySidesInOrder(i);
BlockPos pos = WorldUtil.getCoordsFromSide(side, this.getPos(), 0);
TileEntity tile = this.worldObj.getTileEntity(pos);
if(tile instanceof TileEntityLaserRelayItem){
2016-05-08 21:09:58 +02:00
if(tileFound != null){
return null;
}
else{
tileFound = (TileEntityLaserRelayItem)tile;
2016-05-08 21:09:58 +02:00
}
}
}
}
return tileFound;
}
@Override
public boolean canInsertItem(int index, ItemStack stack, EnumFacing direction){
2016-05-08 21:09:58 +02:00
return this.isItemValidForSlot(index, stack);
}
@Override
public boolean canExtractItem(int index, ItemStack stack, EnumFacing direction){
SpecificItemHandlerInfo handler = this.getSwitchedIndexHandler(index);
2016-05-08 21:09:58 +02:00
if(handler != null){
if(this.isWhitelisted(handler, stack)){
if(ItemStack.areItemsEqual(handler.handler.getStackInSlot(handler.switchedIndex), stack)){
ItemStack gaveBack = handler.handler.extractItem(handler.switchedIndex, stack.stackSize, true);
return gaveBack != null;
}
2016-05-08 21:09:58 +02:00
}
}
return false;
}
private boolean isWhitelisted(SpecificItemHandlerInfo handler, ItemStack stack){
2016-05-11 20:59:38 +02:00
boolean whitelisted = handler.relayInQuestion.isWhitelisted(stack);
TileEntityLaserRelayItem connected = this.getConnectedRelay();
2016-05-16 22:52:27 +02:00
if(connected != null && connected != handler.relayInQuestion){
2016-05-11 20:59:38 +02:00
return whitelisted && connected.isWhitelisted(stack);
}
else{
return whitelisted;
}
}
2016-05-08 21:09:58 +02:00
@Override
public boolean isItemValidForSlot(int index, ItemStack stack){
SpecificItemHandlerInfo handler = this.getSwitchedIndexHandler(index);
2016-05-08 21:09:58 +02:00
if(handler != null){
if(this.isWhitelisted(handler, stack)){
ItemStack gaveBack = handler.handler.insertItem(handler.switchedIndex, stack, true);
return !ItemStack.areItemStacksEqual(gaveBack, stack);
}
2016-05-08 21:09:58 +02:00
}
return false;
}
@Override
public void clear(){
for(int i = 0; i < this.getSizeInventory(); i++){
this.removeStackFromSlot(i);
}
}
@Override
public void setInventorySlotContents(int i, ItemStack stack){
if(stack != null){
SpecificItemHandlerInfo handler = this.getSwitchedIndexHandler(i);
2016-05-08 21:09:58 +02:00
if(handler != null){
ItemStack toInsert = stack.copy();
ItemStack inSlot = handler.handler.getStackInSlot(handler.switchedIndex);
2016-05-08 21:09:58 +02:00
if(inSlot != null){
toInsert.stackSize -= inSlot.stackSize;
}
handler.handler.insertItem(handler.switchedIndex, toInsert, false);
2016-05-08 21:09:58 +02:00
}
}
else{
this.removeStackFromSlot(i);
}
}
@Override
public int getSizeInventory(){
int size = 0;
List<GenericItemHandlerInfo> infos = this.getItemHandlerInfos();
if(infos != null){
for(GenericItemHandlerInfo info : infos){
for(IItemHandler handler : info.handlers){
size += handler.getSlots();
}
2016-05-08 21:09:58 +02:00
}
}
return size;
}
@Override
public ItemStack getStackInSlot(int i){
SpecificItemHandlerInfo handler = this.getSwitchedIndexHandler(i);
2016-05-08 21:09:58 +02:00
if(handler != null){
return handler.handler.getStackInSlot(handler.switchedIndex);
2016-05-08 21:09:58 +02:00
}
return null;
}
@Override
public ItemStack decrStackSize(int i, int j){
SpecificItemHandlerInfo handler = this.getSwitchedIndexHandler(i);
2016-05-08 21:09:58 +02:00
if(handler != null){
return handler.handler.extractItem(handler.switchedIndex, j, false);
2016-05-08 21:09:58 +02:00
}
return null;
}
@Override
public ItemStack removeStackFromSlot(int index){
SpecificItemHandlerInfo handler = this.getSwitchedIndexHandler(index);
2016-05-08 21:09:58 +02:00
if(handler != null){
ItemStack stackInSlot = handler.handler.getStackInSlot(handler.switchedIndex);
2016-05-08 21:09:58 +02:00
if(stackInSlot != null){
handler.handler.extractItem(handler.switchedIndex, stackInSlot.stackSize, false);
2016-05-08 21:09:58 +02:00
}
return stackInSlot;
}
return null;
}
private static class SpecificItemHandlerInfo{
2016-05-19 20:05:12 +02:00
public final IItemHandler handler;
public final int switchedIndex;
public final TileEntityLaserRelayItem relayInQuestion;
public SpecificItemHandlerInfo(IItemHandler handler, int switchedIndex, TileEntityLaserRelayItem relayInQuestion){
this.handler = handler;
this.switchedIndex = switchedIndex;
this.relayInQuestion = relayInQuestion;
}
}
public static class GenericItemHandlerInfo implements Comparable<GenericItemHandlerInfo>{
2016-05-19 20:05:12 +02:00
public final List<IItemHandler> handlers = new ArrayList<IItemHandler>();
public final TileEntityLaserRelayItem relayInQuestion;
public GenericItemHandlerInfo(TileEntityLaserRelayItem relayInQuestion){
this.relayInQuestion = relayInQuestion;
}
public static boolean containsHandler(List<GenericItemHandlerInfo> infos, IItemHandler handler){
for(GenericItemHandlerInfo info : infos){
if(info.handlers.contains(handler)){
return true;
}
}
return false;
}
public static boolean containsTile(List<GenericItemHandlerInfo> infos, TileEntityLaserRelayItem tile){
for(GenericItemHandlerInfo info : infos){
if(info.relayInQuestion == tile){
return true;
}
}
return false;
}
@Override
public int compareTo(GenericItemHandlerInfo other){
2016-05-16 22:52:27 +02:00
boolean thisWhitelist = this.relayInQuestion instanceof TileEntityLaserRelayItemWhitelist;
boolean otherWhitelist = other.relayInQuestion instanceof TileEntityLaserRelayItemWhitelist;
2016-05-16 22:52:27 +02:00
if(!thisWhitelist && otherWhitelist){
return 1;
}
else if(thisWhitelist && !otherWhitelist){
return -1;
}
else{
return 0;
}
}
}
2016-05-08 21:09:58 +02:00
}