public MeltingRecipe(RecipeMatch input, FluidStack output, int temperature) { this.input = input; this.output = new FluidStack(output, input.amountMatched); this.temperature = temperature; }
@Override public boolean canDrainFluidType(FluidStack fluid) { return fluid.getFluid() == FluidRegistry.WATER; } }
public SmeltingRecipeWrapper(MeltingRecipe recipe) { this.inputs = ImmutableList.of(recipe.input.getInputs()); this.outputs = ImmutableList.of(recipe.getResult()); this.temperature = recipe.getTemperature(); ImmutableList.Builder<FluidStack> builder = ImmutableList.builder(); for(FluidStack fs : TinkerRegistry.getSmelteryFuels()) { if(fs.getFluid().getTemperature(fs) >= temperature) { fs = fs.copy(); fs.amount = 1000; builder.add(fs); } } fuels = builder.build(); }
@Override public String getItemStackDisplayName( ItemStack stack ) { FluidStack fluidStack = this.getFluidStack( stack ); if( fluidStack == null ) { fluidStack = new FluidStack( FluidRegistry.WATER, Fluid.BUCKET_VOLUME ); } return fluidStack.getLocalizedName(); }
@Nonnull @Override public IBakedModel handleItemState(@Nonnull IBakedModel original, ItemStack stack, World world, EntityLivingBase entity) { if (stack.isEmpty() || !stack.getItem().hasCustomProperties() || !stack.hasTagCompound()) { return original; } FluidStack fluid = FluidStack.loadFluidStackFromNBT(stack.getTagCompound()); if (fluid == null || fluid.amount == 0 || fluid.getFluid() == null) { return original; } @SuppressWarnings("deprecation") ResourceLocation location = parent.applyOverride(stack, world, entity); if (location == null) { return original; } try { return CACHE.get(new TankCacheKey(location, fluid.getFluid()), () -> getTexturedModel(original, location, fluid.getFluid())); } catch(ExecutionException e) { TinkerSmeltery.log.error(e); return original; } }
public static String getFluidDisplayName( Object o ) { if( o == null ) { return "** Null"; } FluidStack fluidStack = null; if( o instanceof AEFluidStack ) { fluidStack = ( (AEFluidStack) o ).getFluidStack(); } else if( o instanceof FluidStack ) { fluidStack = (FluidStack) o; } else { return "**Invalid Object"; } String n = fluidStack.getLocalizedName(); if( n == null || "".equalsIgnoreCase( n ) ) { n = fluidStack.getUnlocalizedName(); } return n == null ? "** Null" : n; }
public FluidStack drain(EnumFacing from, FluidStack resource, boolean doDrain) { if (sideTanks[from.ordinal()].getFluid() == null || !(sideTanks[from.ordinal()].getFluid().isFluidEqual(resource))) { return new FluidStack(resource.getFluid(), 0); } return drain(from, resource.amount, doDrain); }
info.fluid = new FluidStack(FluidRegistry.LAVA, 0); info.maxCap = 1; } else { info.fluid = currentFuel.copy(); info.fluid.amount = 0; info.maxCap = currentFuel.amount; FluidStack tankFluid = tank.getFluid(); assert tankFluid != null; info.fluid = tankFluid.copy(); info.heat = temperature + 300; info.maxCap = tank.getCapacity(); info.fluid = tank.getFluid().copy(); info.heat = info.fluid.getFluid().getTemperature(info.fluid); info.maxCap = tank.getCapacity(); else if(tank.getFluid().isFluidEqual(info.fluid)) { info.fluid.amount += tank.getFluidAmount(); info.maxCap += tank.getCapacity();
@Override public int fill(FluidStack resource, boolean doFill) { // Safeety check, it seems sometimes it can happen that something creates an invalid fluidstack? // does some mod register a fluid with an empty string as name..? if(StringUtils.isNullOrEmpty(FluidRegistry.getFluidName(resource.getFluid()))) { return 0; } // check how much space is left in the smeltery int used = getFluidAmount(); int usable = Math.min(maxCapacity - used, resource.amount); if(!doFill) { return usable; } // check if we already have the given liquid for(FluidStack liquid : liquids) { if(liquid.isFluidEqual(resource)) { // yup. add it liquid.amount += usable; parent.onTankChanged(liquids, liquid); return usable; } } // not present yet, add it resource = resource.copy(); resource.amount = usable; liquids.add(resource); parent.onTankChanged(liquids, resource); return usable; }
private boolean isValidWaterContainer(ItemStack stack) { if(stack.isEmpty() || stack.getCount() != 1) return false; if(stack.hasCapability(CapabilityFluidHandler.FLUID_HANDLER_ITEM_CAPABILITY, null)) { IFluidHandler handler = stack.getCapability(CapabilityFluidHandler.FLUID_HANDLER_ITEM_CAPABILITY, null); FluidStack simulate = handler.drain(new FluidStack(FluidRegistry.WATER, Fluid.BUCKET_VOLUME), false); if(simulate != null && simulate.getFluid() == FluidRegistry.WATER && simulate.amount == Fluid.BUCKET_VOLUME) return true; } return false; }
public void writeToNBT(NBTTagCompound tag) { NBTTagList taglist = new NBTTagList(); for(FluidStack liquid : liquids) { if(FluidRegistry.getFluidName(liquid.getFluid()) == null) { TinkerSmeltery.log.error("Error trying to save fluids inside smeltery! Invalid Liquid found! Smeltery contents:"); for(FluidStack liquid2 : liquids) { TinkerSmeltery.log.error(" " + liquid2.getUnlocalizedName() + "/" + liquid2.amount + "mb"); } continue; } NBTTagCompound fluidTag = new NBTTagCompound(); liquid.writeToNBT(fluidTag); taglist.appendTag(fluidTag); } tag.setTag("Liquids", taglist); tag.setInteger("LiquidCapacity", maxCapacity); }
@Override public String getMessage() { final IAEFluidStack fluid = this.getFluidStack(); if( fluid != null ) { return fluid.getFluidStack().getLocalizedName(); } return null; }
private void handleAlloyIMCs() { for(NBTTagList taglist : alloys) { List<FluidStack> fluids = Lists.newLinkedList(); for(int i = 0; i < taglist.tagCount(); i++) { NBTTagCompound tag = taglist.getCompoundTagAt(i); FluidStack fs = FluidStack.loadFluidStackFromNBT(tag); if(fs == null) { fluids.clear(); break; } fluids.add(fs); } // needs at least 3 fluids if(fluids.size() > 2) { FluidStack output = fluids.get(0); FluidStack[] input = new FluidStack[fluids.size() - 1]; input = fluids.subList(1, fluids.size()).toArray(input); TinkerRegistry.registerAlloy(output, input); log.debug("Added integration alloy: " + output.getLocalizedName()); } } }
public FluidStack getUsableFluid() { if(fluid == null) { return null; } FluidStack stack = this.fluid.copy(); stack.amount -= locked; return stack; }
fluid = new FluidStack(TinkerFluids.blood, 20); liquids.fill(fluid.copy(), true);
@Override public FluidStack drain(FluidStack resource, boolean doDrain) { // search for the resource ListIterator<FluidStack> iter = liquids.listIterator(); while(iter.hasNext()) { FluidStack liquid = iter.next(); if(liquid.isFluidEqual(resource)) { int drainable = Math.min(resource.amount, liquid.amount); if(doDrain) { liquid.amount -= drainable; if(liquid.amount <= 0) { iter.remove(); } parent.onTankChanged(liquids, liquid); } // return drained amount resource = resource.copy(); resource.amount = drainable; return resource; } } // nothing drained return null; }
@Override public void toBytes(ByteBuf buf) { writePos(pos, buf); buf.writeInt(liquids.size()); for(FluidStack liquid : liquids) { NBTTagCompound fluidTag = new NBTTagCompound(); liquid.writeToNBT(fluidTag); ByteBufUtils.writeTag(buf, fluidTag); } } }
/** Checks if the given fluidstack can be used as smeltery fuel */ public static boolean isSmelteryFuel(FluidStack in) { for(Map.Entry<FluidStack, Integer> entry : smelteryFuels.entrySet()) { if(entry.getKey().isFluidEqual(in)) { return true; } } return false; }
public enum TankCapacityGetter implements IItemPropertyGetter { INSTANCE; @Override public float apply(ItemStack stack, World worldIn, EntityLivingBase entityIn) { if(!stack.hasTagCompound()) { return 0; } FluidStack fluid = FluidStack.loadFluidStackFromNBT(stack.getTagCompound()); if (fluid != null && fluid.amount > 0) { return (float)fluid.amount / TileTank.CAPACITY; } return 0; } } }
@Override public boolean isValidInput(@Nonnull FluidStack item) { for (IRecipeInput ri : inputs) { if (item.getFluid() != null && item.isFluidEqual(ri.getFluidInput())) { return true; } } return false; }