capacidaddealmacenamiento.java

package modmercenario.poderes;

import java.util.ArrayList;
import java.util.concurrent.Callable;

import modmercenario.utilidades.util;
import net.minecraft.item.ItemStack;
import net.minecraft.nbt.NBTBase;
import net.minecraft.nbt.NBTTagCompound;
import net.minecraft.nbt.NBTTagList;
import net.minecraft.util.EnumFacing;
import net.minecraftforge.common.capabilities.Capability;
import net.minecraftforge.common.capabilities.CapabilityInject;
import net.minecraftforge.common.capabilities.CapabilityManager;
import net.minecraftforge.common.capabilities.Capability.IStorage;
import net.minecraftforge.items.IItemHandler;
import net.minecraftforge.items.IItemHandlerModifiable;
import net.minecraftforge.items.ItemStackHandler;

public class capacidaddealmacenamiento<T> {

	@CapabilityInject(IItemHandler.class)
	public static Capability<IItemHandler> ITEM_HANDLER_CAPABILITY = null;

	private int Slots = 36;
	private ArrayList<ItemStack> chestInventory = new ArrayList<ItemStack>(Slots);

	boolean inicializado = false;
	boolean ejecutar = false;
	int redstone = 0;
  byte accion = 0;
	long accionstart = 0;
	int ticksmax = 0;
	long currenttime = 0;
	// llevar las animaciones en el mundo local
	long maxtimed = 1000;
	// dexbloquear si se atasca en el servidor
	long inicializaciontime = 0; // System.currentTimeMillis());
	// fecha de la inicializacion
	long ultrevisioninv = 0;
	// ultima vez que se revizo el inventario
 
  

	public int getSlots() {
		return Slots;
	}

	public void setSlots(int slots) {
		Slots = slots;
	}

	public ArrayList<ItemStack> getChestInventory() {
		return chestInventory;
	}

	public void setChestInventory(ArrayList<ItemStack> chestInventory) {
		this.chestInventory = chestInventory;
	}

	public boolean isInicializado() {
		return inicializado;
	}

	public void setInicializado(boolean inicializado) {
		this.inicializado = inicializado;
	}

	public boolean isEjecutar() {
		return ejecutar;
	}

	public void setEjecutar(boolean ejecutar) {
		this.ejecutar = ejecutar;
	}

	public int getRedstone() {
		return redstone;
	}

	public void setRedstone(int redstone) {
		this.redstone = redstone;
	}

	public byte getAccion() {
		return accion;
	}

	public void setAccion(byte accion) {
		this.accion = accion;
	}

	public long getAccionstart() {
		return accionstart;
	}

	public void setAccionstart(long accionstart) {
		this.accionstart = accionstart;
	}

	public int getTicksmax() {
		return ticksmax;
	}

	public void setTicksmax(int ticksmax) {
		this.ticksmax = ticksmax;
	}

	public long getCurrenttime() {
		return currenttime;
	}

	public void setCurrenttime(long currenttime) {
		this.currenttime = currenttime;
	}

	public long getMaxtimed() {
		return maxtimed;
	}

	public void setMaxtimed(long maxtimed) {
		this.maxtimed = maxtimed;
	}

	public long getInicializaciontime() {
		return inicializaciontime;
	}

	public void setInicializaciontime(long inicializaciontime) {
		this.inicializaciontime = inicializaciontime;
	}

	public long getUltrevisioninv() {
		return ultrevisioninv;
	}

	public void setUltrevisioninv(long ultrevisioninv) {
		this.ultrevisioninv = ultrevisioninv;
	}
	//#######################################################################################
	public static void register() {
		CapabilityManager.INSTANCE.register(IItemHandler.class, new Capability.IStorage<IItemHandler>() {
			@Override
			public NBTBase writeNBT(Capability<IItemHandler> capability, IItemHandler instance, EnumFacing side) {
				NBTTagList nbtTagList = new NBTTagList();
				int size = instance.getSlots();
				for (int i = 0; i < size; i++) {
					ItemStack stack = instance.getStackInSlot(i);
					if (!stack.isEmpty()) {
						NBTTagCompound itemTag = new NBTTagCompound();
						itemTag.setInteger("Slot", i);
						stack.writeToNBT(itemTag);
						nbtTagList.appendTag(itemTag);
					}
				}
				return nbtTagList;
			}

			//#######################################################################################
			@Override
			public void readNBT(Capability<IItemHandler> capability, IItemHandler instance, EnumFacing side,
					NBTBase base) {
				if (!(instance instanceof IItemHandlerModifiable))
					throw new RuntimeException("IItemHandler instance does not implement IItemHandlerModifiable");
				IItemHandlerModifiable itemHandlerModifiable = (IItemHandlerModifiable) instance;
				NBTTagList tagList = (NBTTagList) base;
				for (int i = 0; i < tagList.tagCount(); i++) {
					NBTTagCompound itemTags = tagList.getCompoundTagAt(i);
					int j = itemTags.getInteger("Slot");

					if (j >= 0 && j < instance.getSlots()) {
						itemHandlerModifiable.setStackInSlot(j, new ItemStack(itemTags));
					}
				}
			}
		}, new Callable<ItemStackHandler>() {
			@Override
			public ItemStackHandler call() throws Exception {
				return new ItemStackHandler();
			}
		});
	}
	
	//#######################################################################################
}