public int getProgress() { ItemStack stack = inventory.getStackInSlot(0); if (stack == null) return 0; Item item = stack.getItem(); FluidStack fluidstack = null; int capacity = 0; if (item instanceof IFluidContainerItem) { IFluidContainerItem iFluidContainerItem = (IFluidContainerItem) stack.getItem(); fluidstack = iFluidContainerItem.getFluid(stack); capacity = iFluidContainerItem.getCapacity(stack); } else if (FluidContainerRegistry.isContainer(stack)) { fluidstack = FluidContainerRegistry.getFluidForFilledItem(stack); capacity = FluidContainerRegistry.getContainerCapacity(fill ? tank.getFluid() : fluidstack, stack); } if (fluidstack == null || capacity <= 0) { if (fill) return 0; return 16; } if (fill) return (int) ((fluidstack.amount * 16D) / capacity); return (int) (((capacity - fluidstack.amount) * 16D) / capacity); }
@Override public void updateEntity() { super.updateEntity(); if (worldObj.isRemote) return; ItemStack stack = inventory.getStackInSlot(0); if (stack != null) { Item stackItem = stack.getItem(); if (stackItem instanceof IFluidContainerItem) { IFluidContainerItem iFluidContainerItem = (IFluidContainerItem) stackItem; if (fill) { if (!tank.isEmpty()) { int amount = 128; if (tank.getFluidAmount() < amount) amount = tank.getFluidAmount(); if (energy >= amount) { drain( ForgeDirection.UNKNOWN, iFluidContainerItem.fill(stack, new FluidStack(tank.getFluid(), amount), true), true); energy -= amount; } } } else { FluidStack contained = iFluidContainerItem.getFluid(stack); if (!fill && !tank.isFull() && contained != null && contained.amount > 0) { int amount = 64; if (tank.getFreeSpace() < amount) amount = tank.getFreeSpace(); if (amount > contained.amount) amount = contained.amount; iFluidContainerItem.drain( stack, fill(ForgeDirection.UNKNOWN, new FluidStack(contained, amount), true), true); } } } else if (FluidContainerRegistry.isContainer(stack)) { if (fill) { if (!tank.isEmpty()) { int amount = FluidContainerRegistry.getContainerCapacity(tank.getFluid(), stack); if (amount > 0 && energy >= amount && tank.getFluidAmount() >= amount) { ItemStack filledContainer = FluidContainerRegistry.fillFluidContainer( new FluidStack(tank.getFluid(), amount), stack); if (filledContainer != null && filledContainer.getItem() != null && filledContainer.stackSize > 0) { energy -= amount; drain(ForgeDirection.UNKNOWN, amount, true); inventory.setInventorySlotContents(0, filledContainer.copy()); } } } } else { FluidStack contained = FluidContainerRegistry.getFluidForFilledItem(stack); if (contained != null && contained.amount > 0 && tank.getFreeSpace() >= contained.amount) { if (fill(ForgeDirection.UNKNOWN, contained, false) == contained.amount) { fill(ForgeDirection.UNKNOWN, contained, true); ItemStack drainedContainer = FluidContainerRegistry.drainFluidContainer(stack); if (drainedContainer != null && drainedContainer.getItem() != null && drainedContainer.stackSize > 0) inventory.setInventorySlotContents(0, drainedContainer.copy()); } } } } if (getProgress() >= 16) { stack = getStackInSlot(0); if (stack != null) { ItemStack outputStack = getStackInSlot(1); if (outputStack == null || outputStack.getItem() == null || outputStack.stackSize <= 0) { ItemStack copyStack = stack.copy(); copyStack.stackSize = 1; inventory.setInventorySlotContents(1, copyStack); inventory.decrStackSize(0, 1); } } } } }
private void loadItems() { registerVariantNames(); int size = 0; ImmutableList<Item> items = ImmutableList.copyOf(GameData.getItemRegistry().typeSafeIterable()); for (Item item : items) { size += getVariantNames(item).size(); } itemBar = ProgressManager.push("ModelLoader: items", size); for (Item item : items) { // default loading for (String s : (List<String>) getVariantNames(item)) { ResourceLocation file = getItemLocation(s); ModelResourceLocation memory = getInventoryVariant(s); itemBar.step(memory.toString()); IModel model = null; try { model = getModel(file); } catch (IOException e) { // Handled by our finally block. } finally { if (model == null || model == getMissingModel()) { FMLLog.fine( "Item json isn't found for '" + memory + "', trying to load the variant from the blockstate json"); try { registerVariant(getModelBlockDefinition(memory), memory); } catch (Exception exception) { FMLLog.getLogger().warn("Unable to load definition " + memory, exception); } } else stateModels.put(memory, model); } } } ProgressManager.pop(itemBar); // replace vanilla bucket models if desired. done afterwards for performance reasons if (ForgeModContainer.replaceVanillaBucketModel) { // ensure the bucket model is loaded if (!stateModels.containsKey(ModelDynBucket.LOCATION)) { // load forges blockstate json for it ModelResourceLocation memory = getInventoryVariant("forge:dynbucket"); registerVariant(getModelBlockDefinition(memory), memory); } // empty bucket for (String s : getVariantNames(Items.bucket)) { ModelResourceLocation memory = getInventoryVariant(s); try { IModel model = getModel(new ResourceLocation("forge", "item/bucket")); // only on successful load, otherwise continue using the old model stateModels.put(memory, model); } catch (IOException e) { // use the original vanilla model } } setBucketModel(Items.water_bucket); setBucketModel(Items.lava_bucket); // milk bucket only replaced if some mod adds milk if (FluidRegistry.isFluidRegistered("milk")) { // can the milk be put into a bucket? Fluid milk = FluidRegistry.getFluid("milk"); FluidStack milkStack = new FluidStack(milk, FluidContainerRegistry.BUCKET_VOLUME); if (FluidContainerRegistry.getContainerCapacity(milkStack, new ItemStack(Items.bucket)) == FluidContainerRegistry.BUCKET_VOLUME) { setBucketModel(Items.milk_bucket); } } else { // milk bucket if no milk fluid is present for (String s : getVariantNames(Items.milk_bucket)) { ModelResourceLocation memory = getInventoryVariant(s); try { IModel model = getModel(new ResourceLocation("forge", "item/bucket_milk")); // only on successful load, otherwise continue using the old model stateModels.put(memory, model); } catch (IOException e) { // use the original vanilla model } } } } }