@Override public boolean canDrainFluidType(FluidStack fluid) { return fluid.getFluid() == FluidRegistry.WATER; } }
private boolean validFluid(FluidStack fluid) { return fluid != null && fluid.getFluid() != null && fluid.amount > 0; } }
public boolean isValid() { return result != null && result.getFluid() != null && fluids.size() >= 2 && fluids.stream().allMatch(this::validFluid); }
public CastingRecipe(ItemStack output, RecipeMatch cast, FluidStack fluid, boolean consumesCast, boolean switchOutputs) { this(output, cast, fluid, calcCooldownTime(fluid.getFluid(), fluid.amount), consumesCast, switchOutputs); }
@Nullable @Override public FluidStack drain(FluidStack resource, boolean doDrain) { if(resource == null || tank.getFluidAmount() == 0) { return null; } FluidStack fluidStack = tank.getFluid(); assert fluidStack != null; if(fluidStack.getFluid() != resource.getFluid()) { return null; } // same fluid, k return this.drain(resource.amount, doDrain); }
@Override public boolean matches(ItemStack cast, Fluid fluid) { if((cast.isEmpty() && this.cast == null) || (this.cast != null && this.cast.matches(ListUtil.getListFrom(cast)).isPresent())) { return this.fluid.getFluid() == fluid; } return false; }
public static void renderTiledFluid(int x, int y, int width, int height, float depth, FluidStack fluidStack) { TextureAtlasSprite fluidSprite = mc.getTextureMapBlocks().getAtlasSprite(fluidStack.getFluid().getStill(fluidStack).toString()); RenderUtil.setColorRGBA(fluidStack.getFluid().getColor(fluidStack)); renderTiledTextureAtlas(x, y, width, height, depth, fluidSprite, fluidStack.getFluid().isGaseous(fluidStack)); }
public static void renderFluidCuboid(FluidStack fluid, BlockPos pos, double x, double y, double z, double x1, double y1, double z1, double x2, double y2, double z2) { int color = fluid.getFluid().getColor(fluid); renderFluidCuboid(fluid, pos, x, y, z, x1, y1, z1, x2, y2, z2, color); }
public MeltingRecipe(RecipeMatch input, FluidStack output) { this(input, output, calcTemperature(output.getFluid().getTemperature(output), input.amountMatched)); }
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(); }
private AEFluidStack( @Nonnull final FluidStack fluidStack ) { this.fluid = fluidStack.getFluid(); if( this.fluid == null ) { throw new IllegalArgumentException( "Fluid is null." ); } this.setStackSize( fluidStack.amount ); this.setCraftable( false ); this.setCountRequestable( 0 ); if( fluidStack.tag != null ) { this.tagCompound = fluidStack.tag.copy(); } }
/** * Returns a meltingrecipe for the given recipematch, that returns the given fluid-output combination * but the temperature required for it is as if timeAmount would be returned. */ public static MeltingRecipe forAmount(RecipeMatch recipeMatch, FluidStack output, int timeAmount) { return new MeltingRecipe(recipeMatch, output, calcTemperature(output.getFluid().getTemperature(), timeAmount)); }
public ItemStack getCurrentResult() { if(recipe == null) { return null; } Fluid fluid = null; if(tank.getFluid() != null) { fluid = tank.getFluid().getFluid(); } return recipe.getResult(getStackInSlot(0), fluid); }
@Override public String toString() { return this.getStackSize() + "x" + this.getFluidStack().getFluid().getName() + " " + this.tagCompound; }
public int getBrightness() { if(containsFluid()) { assert tank.getFluid() != null; return tank.getFluid().getFluid().getLuminosity(); } return 0; }
@Override public boolean equals( final Object other ) { if( other instanceof AEFluidStack ) { final AEFluidStack is = (AEFluidStack) other; return is.fluid == this.fluid && Platform.itemComparisons().isNbtTagEqual( this.tagCompound, is.tagCompound ); } else if( other instanceof FluidStack ) { final FluidStack is = (FluidStack) other; return is.getFluid() == this.fluid && Platform.itemComparisons().isNbtTagEqual( this.tagCompound, is.tag ); } return false; }
public OnCasted(ICastingRecipe recipe, TileCasting tile) { super(recipe, tile); ItemStack cast = tile.getStackInSlot(0); assert tile.tank.getFluid() != null; Fluid fluid = tile.tank.getFluid().getFluid(); this.output = recipe.getResult(cast, fluid).copy(); this.consumeCast = recipe.consumesCast(); this.switchOutputs = recipe.switchOutputs(); }
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; }
@Subscribe public void postInit(FMLPostInitializationEvent event) { registerSmelteryFuel(); registerMeltingCasting(); // register remaining cast creation for(FluidStack fs : castCreationFluids) { TinkerRegistry.registerTableCasting(new ItemStack(cast), ItemStack.EMPTY, fs.getFluid(), fs.amount); TinkerRegistry.registerTableCasting(new CastingRecipe(castGem, RecipeMatch.of("gemEmerald"), fs, true, true)); TinkerRegistry.registerTableCasting(new CastingRecipe(castIngot, RecipeMatch.of("ingotBrick"), fs, true, true)); TinkerRegistry.registerTableCasting(new CastingRecipe(castIngot, RecipeMatch.of("ingotBrickNether"), fs, true, true)); TinkerRegistry.registerTableCasting(new CastingRecipe(castIngot, new RecipeMatch.Item(TinkerCommons.searedBrick, 1), fs, true, true)); } proxy.postInit(); TinkerRegistry.tabSmeltery.setDisplayIcon(new ItemStack(searedTank)); }