Java Code Examples for net.minecraftforge.fluids.FluidStack#getFluid()

@Override
public int amountRequested(FluidStack stack){
    int totalRequestingAmount = getTotalRequestedAmount(stack);
    if(totalRequestingAmount > 0) {
        TileEntity te = getTileEntity();
        if(te instanceof IFluidHandler) {

            int count = 0;

            for(ForgeDirection d : ForgeDirection.VALID_DIRECTIONS) {
                FluidTankInfo[] infos = ((IFluidHandler)te).getTankInfo(d);
                if(infos != null) {
                    for(FluidTankInfo info : infos) {
                        if(info.fluid != null && info.fluid.getFluid() == stack.getFluid()) {
                            count += info.fluid.amount;
                        }
                    }
                    if(count > 0) break;
                }
            }

            count += getIncomingFluid(stack.getFluid());
            int requested = Math.max(0, Math.min(stack.amount, totalRequestingAmount - count));
            return requested;
        }

    }
    return 0;
}
 

public static Map.Entry<FluidStack, TofuEnergyStoragedFluid> getSufficientRecipe(FluidStack stack){
    for (Map.Entry<FluidStack, TofuEnergyStoragedFluid> entry : recipes.entrySet()){
        if (entry.getKey().getFluid() == stack.getFluid())
            return entry;
    }
    return null;
}
 

public static Map.Entry<FluidStack, TofuEnergyStoragedFluid> getReversedRecipe(FluidStack stack){
    for (Map.Entry<FluidStack, TofuEnergyStoragedFluid> entry : recipes.entrySet()){
        if (entry.getValue().getOutput().getFluid() == stack.getFluid())
            return entry;
    }

    return null;
}
 

@Override
public FluidStack drain(ForgeDirection from, FluidStack resource, boolean doDrain){
    if(resource != null && canDrain(from, resource.getFluid())) {
        EntityPlayer player = getPlayer();
        if(player != null) {
            int liquidToXP = PneumaticCraftAPIHandler.getInstance().liquidXPs.get(resource.getFluid());
            int pointsDrained = Math.min(getPlayerXP(player), resource.amount / liquidToXP);
            if(doDrain) addPlayerXP(player, -pointsDrained);
            return new FluidStack(resource.getFluid(), pointsDrained * liquidToXP);
        }
    }
    return null;
}
 

private IThermopneumaticProcessingPlantRecipe getValidRecipe(){
    for(IThermopneumaticProcessingPlantRecipe recipe : PneumaticRecipeRegistry.getInstance().thermopneumaticProcessingPlantRecipes) {
        if(recipe.isValidRecipe(inputTank.getFluid(), inventory[4])) {
            if(outputTank.getFluid() == null) {
                return recipe;
            } else {
                FluidStack output = recipe.getRecipeOutput(inputTank.getFluid(), inventory[4]);
                if(output.getFluid() == outputTank.getFluid().getFluid() && output.amount <= outputTank.getCapacity() - outputTank.getFluidAmount()) {
                    return recipe;
                }
            }
        }
    }
    return null;
}
 

@Override
public void loadCraftingRecipes(ItemStack result) {
    FluidStack fluid = Utils.getFluidStack(result);
    if (fluid != null && fluid.getFluid() != null) {
        this.loadCraftingRecipes(fluid);
    }
}
 

@Override
public FluidStack drain(FluidStack resource,
		boolean doDrain) {
	if(this.fluidTank.getFluid() == null || resource.getFluid() != this.fluidTank.getFluid().getFluid())
		return null;

	return this.drain(resource.amount, doDrain);
}
 

public static int getFluidColor(FluidStack fluidStack) {
    if (fluidStack.getFluid() == FluidRegistry.WATER)
        return 0x3094CF;
    else if (fluidStack.getFluid() == FluidRegistry.LAVA)
        return 0xFFD700;
    return fluidStack.getFluid().getColor(fluidStack);
}
 

@Override
public boolean canFillFluidType(FluidStack fluid) {
    if(fluid == null || fluid.getFluid() == null || BarrelLiquidBlacklistRegistry.isBlacklisted(barrel.getTier(), fluid.getFluid().getName()))
        return false;
    
	for (IBarrelMode mode : BarrelModeRegistry.getModes(TriggerType.FLUID))	{
		if (mode.isTriggerFluidStack(fluid))
			return true;
	}
    return false;
}
 

public String getFluidName() {

        FluidStack fluid = this.getFluidStack();

        if (fluid == null) {
            return "No fluid";
        }

        if (fluid.getFluid() == null) {
            return "No fluid";
        }

        return fluid.getFluid().getName();
    }
 

public static String getTranslatedFluidName(FluidStack fluidStack) {
	if (fluidStack == null) return "";
	final Fluid fluid = fluidStack.getFluid();
	String localizedName = fluid.getLocalizedName(fluidStack);
	if (!Strings.isNullOrEmpty(localizedName) && !localizedName.equals(fluid.getUnlocalizedName())) {
		return fluid.getRarity(fluidStack).rarityColor.toString() + localizedName;
	} else {
		return TextFormatting.OBFUSCATED + "LOLNOPE" + TextFormatting.RESET;
	}
}
 

@Override
public boolean canFillFluidType(FluidStack fluidStack) {

    Fluid fluid = fluidStack.getFluid();

    if (fluid == null) {
        return false;
    }

    return ScrubberRecipes.isValidGas(fluid);
}
 

public static int getLightValue(FluidStack fluid)
{
    if(fluid != null && fluid.getFluid() != null)
    {
        return fluid.getFluid().getLuminosity(fluid);
    }
    else
    {
        return 0;
    }
}
 

public static int getLuminosity(FluidStack stack, double density) {
    if (stack.isEmpty()) {
        return 0;
    }
    Fluid fluid = stack.getFluid();
    FluidAttributes attributes = fluid.getAttributes();
    int light = attributes.getLuminosity(stack);
    if (attributes.isGaseous()) {
        light = (int) (light * density);
    }
    return light;
}
 

public void renderItem(ItemRenderType type, ItemStack item, Object... data)
{
	Minecraft.getMinecraft().renderEngine.bindTexture(new ResourceLocation("extracells", "textures/blocks/texmap_tank.png"));
	GL11.glPushMatrix();
	GL11.glTranslatef(0.5F, 0.5F, 0.5F);
	GL11.glScalef(1.0F, -1F, -1F);
	model.render(0.0625f);
	GL11.glScalef(1.0F, -1F, 1.0F);
	model.render(0.0625f);

	if (item != null && item.hasTagCompound())
	{
		FluidStack storedFluid = FluidStack.loadFluidStackFromNBT(item.getTagCompound().getCompoundTag("tileEntity"));
		int tankCapacity = 32000;

		if (storedFluid != null && storedFluid.getFluid() != null)
		{
			Icon fluidIcon = storedFluid.getFluid().getIcon();

			Tessellator tessellator = Tessellator.instance;
			RenderBlocks renderer = new RenderBlocks();

			GL11.glScalef(1.0F, 1.0F, -1.0F);
			renderer.setRenderBounds(0.08F, 0.001F, 0.08F, 0.92, (float) storedFluid.amount / (float) tankCapacity * 0.999F, 0.92F);
			Minecraft.getMinecraft().renderEngine.bindTexture(TextureMap.locationBlocksTexture);
			GL11.glTranslatef(-0.5F, -0.5F, -0.5F);

			GL11.glPushAttrib(GL11.GL_ENABLE_BIT);
			GL11.glEnable(GL11.GL_CULL_FACE);
			GL11.glDisable(GL11.GL_LIGHTING);
			GL11.glEnable(GL11.GL_BLEND);
			GL11.glBlendFunc(GL11.GL_SRC_ALPHA, GL11.GL_ONE_MINUS_SRC_ALPHA);

			tessellator.startDrawingQuads();
			tessellator.setNormal(0.0F, -1F, 0.0F);
			renderer.renderFaceYNeg(Block.blocksList[FluidRegistry.WATER.getBlockID()], 0.0D, 0.0D, 0.0D, fluidIcon);
			tessellator.draw();
			tessellator.startDrawingQuads();
			tessellator.setNormal(0.0F, 1.0F, 0.0F);
			renderer.renderFaceYPos(Block.blocksList[FluidRegistry.WATER.getBlockID()], 0.0D, 0.0D, 0.0D, fluidIcon);
			tessellator.draw();
			tessellator.startDrawingQuads();
			tessellator.setNormal(0.0F, 0.0F, -1F);
			renderer.renderFaceZNeg(Block.blocksList[FluidRegistry.WATER.getBlockID()], 0.0D, 0.0D, 0.0D, fluidIcon);
			tessellator.draw();
			tessellator.startDrawingQuads();
			tessellator.setNormal(0.0F, 0.0F, 1.0F);
			renderer.renderFaceZPos(Block.blocksList[FluidRegistry.WATER.getBlockID()], 0.0D, 0.0D, 0.0D, fluidIcon);
			tessellator.draw();
			tessellator.startDrawingQuads();
			tessellator.setNormal(-1F, 0.0F, 0.0F);
			renderer.renderFaceXNeg(Block.blocksList[FluidRegistry.WATER.getBlockID()], 0.0D, 0.0D, 0.0D, fluidIcon);
			tessellator.draw();
			tessellator.startDrawingQuads();
			tessellator.setNormal(1.0F, 0.0F, 0.0F);
			renderer.renderFaceXPos(Block.blocksList[FluidRegistry.WATER.getBlockID()], 0.0D, 0.0D, 0.0D, fluidIcon);
			tessellator.draw();

			GL11.glPopAttrib();
		}
	}

	GL11.glPopMatrix();
}
 

@Override
public void loadUsageRecipes(FluidStack ingredient) {
    if (ingredient.getFluid() == FluidRegistry.WATER) {
        this.loadAllRecipes();
    }
}
 

@Override
public boolean canFillFluidType(FluidStack fluid) {

    return fluid.getFluid() == FluidRegistry.WATER;
}
 

public static boolean shouldRenderFluid(FluidStack stack) {
    return stack.amount > 0 && stack.getFluid() != null;
}
 

@Override
public boolean canFillFluidType(FluidStack fluidStack) {

    Fluid fluid = fluidStack.getFluid();

    return ScrubberRecipes.isValidGas(fluid);
}
 

public static int getBoostModifierForFluidByFluidStack(FluidStack fluidStack) {

        if (fluidStack == null) return 0;
        if (fluidStack.getFluid() == null) return 0;

        String name = fluidStack.getFluid().getName();

        ModFluid fluid = getFluidByName(name);

        if (fluid == null) return 0;

        return fluid.boostModifier;
    }