[1.12.2] Slot rendering different slot's items

[Cadiboo]

Title says it all basically, probably some small thing that I've failed to do

Slot 1 renders slot 9's itemstack

 

ContainerCoiler.java

package cadiboo.wiptech.block.coiler;

import javax.annotation.Nonnull;

import cadiboo.wiptech.WIPTech;
import cadiboo.wiptech.init.Items;
import cadiboo.wiptech.init.Recipes;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.entity.player.InventoryPlayer;
import net.minecraft.inventory.Container;
import net.minecraft.inventory.Slot;
import net.minecraft.item.ItemStack;
import net.minecraft.util.EnumFacing;
import net.minecraftforge.items.CapabilityItemHandler;
import net.minecraftforge.items.IItemHandler;
import net.minecraftforge.items.SlotItemHandler;

public class ContainerCoiler extends Container {

	public ContainerCoiler(InventoryPlayer playerInv, final TileEntityCoiler coiler) {
		IItemHandler inventory = coiler.getCapability(CapabilityItemHandler.ITEM_HANDLER_CAPABILITY, EnumFacing.NORTH);


		for(int i=0; i<10; i++) {
			
			if ( (i & 1) == 0 ) // even - Input slot
			{
				addSlotToContainer(new SlotItemHandler(inventory, i, 19 + 30*i/2, 17) {
					@Override
					public void onSlotChanged() {
						coiler.markDirty();
					}
				});

			}
			else
			{
				addSlotToContainer(new SlotItemHandler(inventory, i, 19 + 30*((i-1)/2), 53) {
					/*@Override
					public void onSlotChanged() {
						coiler.markDirty();
					}
					
					@Override
					public boolean isItemValid(@Nonnull ItemStack stack){
						return Recipes.getCoilResult(stack)!=null && Recipes.getCoilResult(stack).size()>0;
					}*/
				});
			}
		}

		for (int i = 0; i < 3; i++) {
			for (int j = 0; j < 9; j++) {
				addSlotToContainer(new Slot(playerInv, j + i * 9 + 9, 8 + j * 18, 84 + i * 18));
			}
		}

		for (int k = 0; k < 9; k++) {
			addSlotToContainer(new Slot(playerInv, k, 8 + k * 18, 142));
		}
	}

	@Override
	public boolean canInteractWith(EntityPlayer player) {
		return true;
	}

	@Override
	public ItemStack transferStackInSlot(EntityPlayer player, int index) {
		ItemStack itemstack = ItemStack.EMPTY;
		Slot slot = inventorySlots.get(index);

		if (slot != null && slot.getHasStack()) {
			ItemStack itemstack1 = slot.getStack();
			itemstack = itemstack1.copy();

			int containerSlots = inventorySlots.size() - player.inventory.mainInventory.size();

			if (index < containerSlots) {
				if (!this.mergeItemStack(itemstack1, containerSlots, inventorySlots.size(), true)) {
					return ItemStack.EMPTY;
				}
			} else if (!this.mergeItemStack(itemstack1, 0, containerSlots, false)) {
				return ItemStack.EMPTY;
			}

			if (itemstack1.getCount() == 0) {
				slot.putStack(ItemStack.EMPTY);
			} else {
				slot.onSlotChanged();
			}

			if (itemstack1.getCount() == itemstack.getCount()) {
				return ItemStack.EMPTY;
			}

			slot.onTake(player, itemstack1);
		}

		return itemstack;
	}


}

 

BlockCoiler.java

package cadiboo.wiptech.block.coiler;

import java.util.List;
import java.util.Random;

import javax.annotation.Nullable;

import cadiboo.wiptech.ModGuiHandler;
import cadiboo.wiptech.WIPTech;
import cadiboo.wiptech.block.BlockTileEntity;
import net.minecraft.block.BlockHorizontal;
import net.minecraft.block.material.Material;
import net.minecraft.block.properties.IProperty;
import net.minecraft.block.properties.PropertyDirection;
import net.minecraft.block.state.BlockStateContainer;
import net.minecraft.block.state.IBlockState;
import net.minecraft.client.util.ITooltipFlag;
import net.minecraft.entity.EntityLivingBase;
import net.minecraft.entity.item.EntityItem;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.init.SoundEvents;
import net.minecraft.item.ItemStack;
import net.minecraft.util.EnumFacing;
import net.minecraft.util.EnumHand;
import net.minecraft.util.EnumParticleTypes;
import net.minecraft.util.Mirror;
import net.minecraft.util.Rotation;
import net.minecraft.util.SoundCategory;
import net.minecraft.util.math.BlockPos;
import net.minecraft.world.World;
import net.minecraftforge.fml.relauncher.Side;
import net.minecraftforge.fml.relauncher.SideOnly;
import net.minecraftforge.items.CapabilityItemHandler;
import net.minecraftforge.items.IItemHandler;

public class BlockCoiler extends BlockTileEntity<TileEntityCoiler>{

	public BlockCoiler (String name, Material material) {
		super(name, material);
		this.setDefaultState(this.blockState.getBaseState().withProperty(FACING, EnumFacing.NORTH));
		this.setTileEntity();
		this.setNonSolidBlock();
	}

	@Override
	public void addInformation(ItemStack stack, World worldIn, List<String> tooltip, ITooltipFlag flagIn) {
		tooltip.add("\u00A76\u00A7o"+"Takes Spools and winds them into high performance coils.");
	}

	public static final PropertyDirection FACING = BlockHorizontal.FACING;

	@SideOnly(Side.CLIENT)
	public void randomDisplayTick(IBlockState stateIn, World worldIn, BlockPos pos, Random rand)
	{
		if (TileEntityCoiler.isWinding(this.getTileEntity(worldIn, pos)))
		{
			EnumFacing enumfacing = (EnumFacing)stateIn.getValue(FACING);
			double x = (double)pos.getX() + 0.5D;
			double y = (double)pos.getY() + 0.5D;
			double z = (double)pos.getZ() + 0.5D;
			double d4 = rand.nextDouble() * 0.6D - 0.3D;

			if (rand.nextDouble() < 0.1D)
			{
				worldIn.playSound((double)pos.getX() + 0.5D, (double)pos.getY(), (double)pos.getZ() + 0.5D, SoundEvents.BLOCK_PISTON_EXTEND, SoundCategory.BLOCKS, 1.0F, 1.0F, false);
			}

			worldIn.spawnParticle(EnumParticleTypes.VILLAGER_HAPPY, x + d4, y+0.4+(d4/10), y + d4, 0.0D, 0.0D, 0.0D);

		}
	}

	private double randomBetween(int min, int max) {
		return new Random().nextInt((int) ((max - min)+1) )+min;
	}

	@Override
	public boolean onBlockActivated(World world, BlockPos pos, IBlockState state, EntityPlayer player, EnumHand hand, EnumFacing side, float hitX, float hitY, float hitZ)
	{
		if (!world.isRemote) {
			TileEntityCoiler tile = getTileEntity(world, pos);
			IItemHandler itemHandler = tile.getCapability(CapabilityItemHandler.ITEM_HANDLER_CAPABILITY, side);
			WIPTech.logger.info("player.isSneaking(): "+player.isSneaking());
			if (!player.isSneaking()) {
				player.openGui(WIPTech.instance, ModGuiHandler.COILER, world, pos.getX(), pos.getY(), pos.getZ());
			}
		}
		return true;
	}

	public void onBlockAdded(World worldIn, BlockPos pos, IBlockState state)
	{
		this.setDefaultFacing(worldIn, pos, state);
	}

	private void setDefaultFacing(World worldIn, BlockPos pos, IBlockState state)
	{
		if (!worldIn.isRemote)
		{
			IBlockState iblockstate = worldIn.getBlockState(pos.north());
			IBlockState iblockstate1 = worldIn.getBlockState(pos.south());
			IBlockState iblockstate2 = worldIn.getBlockState(pos.west());
			IBlockState iblockstate3 = worldIn.getBlockState(pos.east());
			EnumFacing enumfacing = (EnumFacing)state.getValue(FACING);

			if (enumfacing == EnumFacing.NORTH && iblockstate.isFullBlock() && !iblockstate1.isFullBlock())
			{
				enumfacing = EnumFacing.SOUTH;
			}
			else if (enumfacing == EnumFacing.SOUTH && iblockstate1.isFullBlock() && !iblockstate.isFullBlock())
			{
				enumfacing = EnumFacing.NORTH;
			}
			else if (enumfacing == EnumFacing.WEST && iblockstate2.isFullBlock() && !iblockstate3.isFullBlock())
			{
				enumfacing = EnumFacing.EAST;
			}
			else if (enumfacing == EnumFacing.EAST && iblockstate3.isFullBlock() && !iblockstate2.isFullBlock())
			{
				enumfacing = EnumFacing.WEST;
			}

			worldIn.setBlockState(pos, state.withProperty(FACING, enumfacing), 2);
		}
	}

	public IBlockState getStateForPlacement(World worldIn, BlockPos pos, EnumFacing facing, float hitX, float hitY, float hitZ, int meta, EntityLivingBase placer)
	{
		return this.getDefaultState().withProperty(FACING, placer.getHorizontalFacing().getOpposite());
	}


	public void onBlockPlacedBy(World worldIn, BlockPos pos, IBlockState state, EntityLivingBase placer, ItemStack stack)
	{
		worldIn.setBlockState(pos, state.withProperty(FACING, placer.getHorizontalFacing().getOpposite()), 2);
	}

	public IBlockState getStateFromMeta(int meta)
	{
		EnumFacing enumfacing = EnumFacing.getFront(meta);

		if (enumfacing.getAxis() == EnumFacing.Axis.Y)
		{
			enumfacing = EnumFacing.NORTH;
		}

		return this.getDefaultState().withProperty(FACING, enumfacing);
	}

	/**
	 * Convert the BlockState into the correct metadata value
	 */
	public int getMetaFromState(IBlockState state)
	{
		return ((EnumFacing)state.getValue(FACING)).getIndex();
	}

	/**
	 * Returns the blockstate with the given rotation from the passed blockstate. If inapplicable, returns the passed
	 * blockstate.
	 */
	public IBlockState withRotation(IBlockState state, Rotation rot)
	{
		return state.withProperty(FACING, rot.rotate((EnumFacing)state.getValue(FACING)));
	}

	/**
	 * Returns the blockstate with the given mirror of the passed blockstate. If inapplicable, returns the passed
	 * blockstate.
	 */
	public IBlockState withMirror(IBlockState state, Mirror mirrorIn)
	{
		return state.withRotation(mirrorIn.toRotation((EnumFacing)state.getValue(FACING)));
	}

	protected BlockStateContainer createBlockState()
	{
		return new BlockStateContainer(this, new IProperty[] {FACING});
	}

	@Override
	public void breakBlock(World world, BlockPos pos, IBlockState state) {
		TileEntityCoiler tile = getTileEntity(world, pos);
		IItemHandler itemHandler = tile.getCapability(CapabilityItemHandler.ITEM_HANDLER_CAPABILITY, EnumFacing.NORTH);
		for(int i = 0; i<2; i++) {
			ItemStack stack = itemHandler.getStackInSlot(i);
			if (!stack.isEmpty()) {
				EntityItem item = new EntityItem(world, pos.getX(), pos.getY(), pos.getZ(), stack);
				world.spawnEntity(item);
			}
		}
		super.breakBlock(world, pos, state);
	}

	@Nullable
	@Override
	public TileEntityCoiler createTileEntity(World world, IBlockState state) {
		return new TileEntityCoiler();
	}

}

 

TileEntityCoiler.java

package cadiboo.wiptech.block.coiler;

import java.util.ArrayList;

import javax.annotation.Nullable;

import cadiboo.wiptech.WIPTech;
import cadiboo.wiptech.block.coiler.TileEntityCoiler;
import cadiboo.wiptech.init.Items;
import cadiboo.wiptech.init.Recipes;
import cadiboo.wiptech.network.PacketRequestUpdateCoiler;
import cadiboo.wiptech.network.PacketUpdateCoiler;
import net.minecraft.item.ItemStack;
import net.minecraft.nbt.NBTTagCompound;
import net.minecraft.tileentity.TileEntity;
import net.minecraft.util.EnumFacing;
import net.minecraft.util.ITickable;
import net.minecraft.util.math.AxisAlignedBB;
import net.minecraftforge.common.capabilities.Capability;
import net.minecraftforge.fml.common.network.NetworkRegistry;
import net.minecraftforge.items.CapabilityItemHandler;
import net.minecraftforge.items.ItemStackHandler;

public class TileEntityCoiler extends TileEntity implements ITickable {

	public float WindTime;
	//private int activeSlot = -1;
	public long lastChangeTime;

	public ItemStackHandler inventory = new ItemStackHandler(10) {
		@Override
		protected void onContentsChanged(int slot) {
			if (!world.isRemote) {
				lastChangeTime = world.getTotalWorldTime();
				WIPTech.network.sendToAllAround(new PacketUpdateCoiler(TileEntityCoiler.this), new NetworkRegistry.TargetPoint(world.provider.getDimension(), pos.getX(), pos.getY(), pos.getZ(), 64));
			}
		};
	};


	@Override
	public NBTTagCompound writeToNBT(NBTTagCompound compound) {
		compound.setTag("inventory", inventory.serializeNBT());
		compound.setLong("lastChangeTime", lastChangeTime);
		compound.setFloat("WindTime", WindTime);
		return super.writeToNBT(compound);
	}

	@Override
	public void readFromNBT(NBTTagCompound compound) {
		inventory.deserializeNBT(compound.getCompoundTag("inventory"));
		lastChangeTime = compound.getLong("lastChangeTime");
		WindTime = compound.getFloat("WindTime");
		super.readFromNBT(compound);
	}

	@Override
	public boolean hasCapability(Capability<?> capability, @Nullable EnumFacing facing) {
		return capability == CapabilityItemHandler.ITEM_HANDLER_CAPABILITY || super.hasCapability(capability, facing);
	}

	@Nullable
	@Override
	public <T> T getCapability(Capability<T> capability, @Nullable EnumFacing facing) {
		return capability == CapabilityItemHandler.ITEM_HANDLER_CAPABILITY ? (T)inventory : super.getCapability(capability, facing);
	}

	@Override
	public void onLoad() {
		if (world.isRemote) {
			WIPTech.network.sendToServer(new PacketRequestUpdateCoiler(this));
		}
	}

	@Override
	public AxisAlignedBB getRenderBoundingBox() {
		return new AxisAlignedBB(getPos(), getPos().add(1, 1, 1));
	}

	@Override
	public void update() {
		if(world.getBlockState(pos).getBlock() != this.getBlockType()) return;
		if(WindTime > 0) {
			--WindTime;
			if(!canCoil()) {
				WindTime = 0;
			}
			else if (WindTime <= 0) {
				WindItem();
			}
		}
		else {
			if(canCoil())
			{
				this.setWindTime((int) Recipes.getCoilResult(inventory.getStackInSlot(1)).get(7) * 1.0F);
			} else {
				WindTime = 0;
			}
		}
	}

	private void WindItem()
	{
		if(inventory.getStackInSlot(0) != null && !inventory.getStackInSlot(1).isEmpty()){

			/*ItemStack stack = inventory.getStackInSlot(0);
			ArrayList resultList = (ArrayList) Recipes.getCoilResult(inventory.getStackInSlot(1));
			if(resultList !=null) {
				inventory.insertItem(2, ((ItemStack) resultList.get(1)).copy(), false);
				inventory.insertItem(3, ((ItemStack) resultList.get(2)).copy(), false);
				inventory.insertItem(4, ((ItemStack) resultList.get(3)).copy(), false);
				inventory.insertItem(5, ((ItemStack) resultList.get(4)).copy(), false);
				inventory.insertItem(6, ((ItemStack) resultList.get(5)).copy(), false);
				inventory.insertItem(7, ((ItemStack) resultList.get(6)).copy(), false);
				inventory.extractItem(1, 1, false);
			} else {
				WIPTech.logger.info("ERROR resultList =null so could NOT Coil ITEM");
			}
			return;*/
		} else {
			WIPTech.logger.info("ERROR COULD NOT Coil ITEM");
			WindTime = 0;
			return;
		}
	}

	private boolean canCoil() {
		if(inventory.getStackInSlot(0) != null && !inventory.getStackInSlot(0).isEmpty())
		{
			
			/*ItemStack stack = inventory.getStackInSlot(0);
			ArrayList resultsList = (ArrayList) Recipes.getCoilResult(inventory.getStackInSlot(1));

			boolean recipeExists = resultsList!=null;
			if(recipeExists) {
				boolean slot0 = !inventory.getStackInSlot(0).isEmpty();
				boolean slot1 = !inventory.getStackInSlot(1).isEmpty();
				boolean slot2 = inventory.getStackInSlot(2).getCount() < inventory.getStackInSlot(2).getMaxStackSize();
				boolean slot3 = inventory.getStackInSlot(3).getCount() < inventory.getStackInSlot(3).getMaxStackSize();
				boolean slot4 = inventory.getStackInSlot(4).getCount() < inventory.getStackInSlot(4).getMaxStackSize();
				boolean slot5 = inventory.getStackInSlot(5).getCount() < inventory.getStackInSlot(5).getMaxStackSize();
				boolean slot6 = inventory.getStackInSlot(6).getCount() < inventory.getStackInSlot(6).getMaxStackSize();
				boolean slot7 = inventory.getStackInSlot(7).getCount() < inventory.getStackInSlot(7).getMaxStackSize();

				if(slot0 && slot1 && slot2 && slot3 && slot4 && slot5 && slot6 && slot7) {
					recipeExists = recipeExists && resultsList.size()>0;
					if(recipeExists) {
						recipeExists = recipeExists && resultsList.get(0)!=null;
						if(recipeExists) {
							slot2 = slot2&& (ItemStack) resultsList.get(1)!=null;
							slot3 = slot3&& (ItemStack) resultsList.get(2)!=null;
							slot4 = slot4&& (ItemStack) resultsList.get(3)!=null;
							slot5 = slot5&& (ItemStack) resultsList.get(4)!=null;
							slot6 = slot6&& (ItemStack) resultsList.get(5)!=null;
							slot7 = slot7&& (ItemStack) resultsList.get(6)!=null;
							if(slot0 && slot1 && slot2 && slot3 && slot4 && slot5 && slot6 && slot7) {
								slot2 = slot2&& inventory.insertItem(2, ((ItemStack) resultsList.get(1)).copy(), true).isEmpty();
								slot3 = slot3&& inventory.insertItem(3, ((ItemStack) resultsList.get(2)).copy(), true).isEmpty();
								slot4 = slot4&& inventory.insertItem(4, ((ItemStack) resultsList.get(3)).copy(), true).isEmpty();
								slot5 = slot5&& inventory.insertItem(5, ((ItemStack) resultsList.get(4)).copy(), true).isEmpty();
								slot6 = slot6&& inventory.insertItem(6, ((ItemStack) resultsList.get(5)).copy(), true).isEmpty();
								slot7 = slot7&& inventory.insertItem(7, ((ItemStack) resultsList.get(6)).copy(), true).isEmpty();
								if(slot0 && slot1 && slot2 && slot3 && slot4 && slot5 && slot6 && slot7) {
									return true;
								}
							}
						}
					}
				}
			}*/

		}
		return false;
	}

	public static boolean isWinding(TileEntityCoiler tileEntity) {
		//return ((BlockCoiler) tileEntity.getWorld().getBlockState(tileEntity.getPos()).getBlock()).isCoiling();
		return tileEntity.isWinding();
	}
	private boolean isWinding() {
		return WindTime > 0;
	}

	public static float getCoilTime(TileEntityCoiler tileEntity) {
		//return (tileEntity.getWorld().getBlockState(tileEntity.getPos()).getBlock());
		return tileEntity.getWindTime();
	}
	private float getWindTime() {
		return WindTime;
	}

	public void setWindTime(TileEntityCoiler tileEntity, float time) {
		tileEntity.setWindTime(time);
	}
	private void setWindTime(float time) {
		WindTime = time;
	}

	public static int getTotalWindTime(TileEntityCoiler tileEntity) {
		return tileEntity.getTotalWindTime();
	}
	private int getTotalWindTime() {
		return (int) (!inventory.getStackInSlot(1).isEmpty()?Recipes.getCoilResult(inventory.getStackInSlot(1)).get(7):0);
	}

	public static int getPercentageOfWindTimeComplete(TileEntityCoiler tileEntity) {
		return tileEntity.getPercentageOfWindTimeComplete();
	}
	private int getPercentageOfWindTimeComplete() {
		return (int) Math.round(getFractionOfWindTimeComplete()*100);
	}

	public static double getFractionOfWindTimeComplete(TileEntityCoiler tileEntity) {
		return tileEntity.getFractionOfWindTimeComplete();
	}
	private double getFractionOfWindTimeComplete() {
		if(getWindTime()>0)
			return (getTotalWindTime() - getWindTime())/getTotalWindTime();
		else
			return 0;
	}

	public static int getPercentageOfWindTimeRemaining(TileEntityCoiler tileEntity) {
		return tileEntity.getPercentageOfWindTimeRemaining();
	}
	private int getPercentageOfWindTimeRemaining() {
		return (int) Math.round(getFractionOfWindTimeRemaining()*100);
	}

	public static double getFractionOfWindTimeRemaining(TileEntityCoiler tileEntity) {
		return tileEntity.getFractionOfWindTimeRemaining();
	}
	private double getFractionOfWindTimeRemaining() {
		//Utils.getLogger().info("getFractionOfWindTimeRemaining: "+getWindTime() / getTotalWindTime());
		if(getWindTime()>0)
			return getWindTime() / getTotalWindTime();
		else
			return getTotalWindTime();
	}

}