20210191346

Committed 14 Dec 2025 03:32PM UTC coverage: 19.514% (-33.5%) from 53.061%

Build # 20210191346

Build Type

push

github

Committed by

rubensworks

Commit Message

Remove deprecations

Run Details

663 of 8728 branches covered (7.6%)

Branch coverage included in aggregate %.

6786 of 29445 relevant lines covered (23.05%)

1.09 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

0.0

/src/main/java/org/cyclops/integrateddynamics/core/recipe/type/RecipeDryingBasin.java

package org.cyclops.integrateddynamics.core.recipe.type;

import com.mojang.datafixers.util.Either;
import net.minecraft.core.HolderLookup;
import net.minecraft.world.item.ItemStack;
import net.minecraft.world.item.Items;
import net.minecraft.world.item.crafting.*;
import net.minecraft.world.item.crafting.display.RecipeDisplay;
import net.minecraft.world.item.crafting.display.SlotDisplay;
import net.minecraft.world.level.Level;
import net.neoforged.neoforge.fluids.FluidStack;
import org.cyclops.cyclopscore.recipe.ItemStackFromIngredient;
import org.cyclops.cyclopscore.recipe.type.IInventoryFluid;
import org.cyclops.integrateddynamics.RegistryEntries;
import org.cyclops.integrateddynamics.core.recipe.display.RecipeDisplayDryingBasin;

import java.util.List;
import java.util.Optional;

/**
 * Drying basin recipe
 * @author rubensworks
 */
public class RecipeDryingBasin implements Recipe<IInventoryFluid> {

    private final Optional<Ingredient> inputIngredient;
    private final Optional<FluidStack> inputFluid;
    private final Optional<Either<ItemStack, ItemStackFromIngredient>> outputItem;
    private final Optional<FluidStack> outputFluid;
    private final int duration;

    private PlacementInfo placementInfo;

    public RecipeDryingBasin(Optional<Ingredient> inputIngredient, Optional<FluidStack> inputFluid,
                             Optional<Either<ItemStack, ItemStackFromIngredient>> outputIngredient, Optional<FluidStack> outputFluid, int duration) {
        this.inputIngredient = inputIngredient;
        this.inputFluid = inputFluid;
        this.outputItem = outputIngredient;
        this.outputFluid = outputFluid;
        this.duration = duration;
    }

    public Optional<Ingredient> getInputIngredient() {
        return inputIngredient;
    }

    public Optional<FluidStack> getInputFluid() {
        return inputFluid;
    }

    public Optional<Either<ItemStack, ItemStackFromIngredient>> getOutputItem() {
        return outputItem;
    }

    public Optional<ItemStack> getOutputItemFirst() {
        return getOutputItem().map(either -> either.map(l -> l, ItemStackFromIngredient::getFirstItemStack));
    }

    public Optional<FluidStack> getOutputFluid() {
        return outputFluid;
    }

    public int getDuration() {
        return duration;
    }

    @Override
    public boolean matches(IInventoryFluid inv, Level worldIn) {
        return inputIngredient.map(p -> p.test(inv.getItem(0))).orElse(inv.getItem(0).isEmpty())
                && inputFluid.map(f -> f.getFluid() == inv.getFluidHandler().getResource(0).getFluid()).orElse(inv.getFluidHandler().getResource(0).isEmpty())
                && inputFluid.map(f -> f.getAmount() <= inv.getFluidHandler().getAmountAsInt(0)).orElse(inv.getFluidHandler().getAmountAsInt(0) == 0);
    }

    @Override
    public ItemStack assemble(IInventoryFluid inv, HolderLookup.Provider registryAccess) {
        return this.getOutputItemFirst().get().copy();
    }

    @Override
    public RecipeSerializer<? extends Recipe<IInventoryFluid>> getSerializer() {
        return RegistryEntries.RECIPESERIALIZER_DRYING_BASIN.get();
    }

    @Override
    public RecipeType<? extends Recipe<IInventoryFluid>> getType() {
        return RegistryEntries.RECIPETYPE_DRYING_BASIN.get();
    }

    @Override
    public PlacementInfo placementInfo() {
        if (this.placementInfo == null) {
            this.placementInfo = PlacementInfo.create(this.inputIngredient.orElse(Ingredient.of(Items.BUCKET)));
        }
        return this.placementInfo;
    }

    @Override
    public RecipeBookCategory recipeBookCategory() {
        return RegistryEntries.RECIPEBOOKCATEGORY_DRYING_BASIN.get();
    }

    @Override
    public List<RecipeDisplay> display() {
        return List.of(new RecipeDisplayDryingBasin(
                this.getInputIngredient().map(Ingredient::display).orElse(SlotDisplay.Empty.INSTANCE),
                this.getInputFluid().orElse(FluidStack.EMPTY),
                this.getOutputItemFirst().<SlotDisplay>map(SlotDisplay.ItemStackSlotDisplay::new).orElse(SlotDisplay.Empty.INSTANCE),
                this.getOutputFluid().orElse(FluidStack.EMPTY),
                new SlotDisplay.ItemSlotDisplay(RegistryEntries.BLOCK_DRYING_BASIN.get().asItem()),
                this.getDuration()
        ));
    }
}

1	package org.cyclops.integrateddynamics.core.recipe.type;
2
3	import com.mojang.datafixers.util.Either;
4	import net.minecraft.core.HolderLookup;
5	import net.minecraft.world.item.ItemStack;
6	import net.minecraft.world.item.Items;
7	import net.minecraft.world.item.crafting.*;
8	import net.minecraft.world.item.crafting.display.RecipeDisplay;
9	import net.minecraft.world.item.crafting.display.SlotDisplay;
10	import net.minecraft.world.level.Level;
11	import net.neoforged.neoforge.fluids.FluidStack;
12	import org.cyclops.cyclopscore.recipe.ItemStackFromIngredient;
13	import org.cyclops.cyclopscore.recipe.type.IInventoryFluid;
14	import org.cyclops.integrateddynamics.RegistryEntries;
15	import org.cyclops.integrateddynamics.core.recipe.display.RecipeDisplayDryingBasin;
16
17	import java.util.List;
18	import java.util.Optional;
19
20	/**
21	* Drying basin recipe
22	* @author rubensworks
23	*/
24	public class RecipeDryingBasin implements Recipe<IInventoryFluid> {
25
26	private final Optional<Ingredient> inputIngredient;
27	private final Optional<FluidStack> inputFluid;
28	private final Optional<Either<ItemStack, ItemStackFromIngredient>> outputItem;
29	private final Optional<FluidStack> outputFluid;
30	private final int duration;
31
32	private PlacementInfo placementInfo;
33
34	public RecipeDryingBasin(Optional<Ingredient> inputIngredient, Optional<FluidStack> inputFluid,
35	Optional<Either<ItemStack, ItemStackFromIngredient>> outputIngredient, Optional<FluidStack> outputFluid, int duration) {	×
36	this.inputIngredient = inputIngredient;	×
37	this.inputFluid = inputFluid;	×
38	this.outputItem = outputIngredient;	×
39	this.outputFluid = outputFluid;	×
40	this.duration = duration;	×
41	}	×
42
43	public Optional<Ingredient> getInputIngredient() {
44	return inputIngredient;	×
45	}
46
47	public Optional<FluidStack> getInputFluid() {
48	return inputFluid;	×
49	}
50
51	public Optional<Either<ItemStack, ItemStackFromIngredient>> getOutputItem() {
52	return outputItem;	×
53	}
54
55	public Optional<ItemStack> getOutputItemFirst() {
56	return getOutputItem().map(either -> either.map(l -> l, ItemStackFromIngredient::getFirstItemStack));	×
57	}
58
59	public Optional<FluidStack> getOutputFluid() {
60	return outputFluid;	×
61	}
62
63	public int getDuration() {
64	return duration;	×
65	}
66
67	@Override
68	public boolean matches(IInventoryFluid inv, Level worldIn) {
69	return inputIngredient.map(p -> p.test(inv.getItem(0))).orElse(inv.getItem(0).isEmpty())	×
70	&& inputFluid.map(f -> f.getFluid() == inv.getFluidHandler().getResource(0).getFluid()).orElse(inv.getFluidHandler().getResource(0).isEmpty())	×
71	&& inputFluid.map(f -> f.getAmount() <= inv.getFluidHandler().getAmountAsInt(0)).orElse(inv.getFluidHandler().getAmountAsInt(0) == 0);	×
72	}
73
74	@Override
75	public ItemStack assemble(IInventoryFluid inv, HolderLookup.Provider registryAccess) {
76	return this.getOutputItemFirst().get().copy();	×
77	}
78
79	@Override
80	public RecipeSerializer<? extends Recipe<IInventoryFluid>> getSerializer() {
81	return RegistryEntries.RECIPESERIALIZER_DRYING_BASIN.get();	×
82	}
83
84	@Override
85	public RecipeType<? extends Recipe<IInventoryFluid>> getType() {
86	return RegistryEntries.RECIPETYPE_DRYING_BASIN.get();	×
87	}
88
89	@Override
90	public PlacementInfo placementInfo() {
91	if (this.placementInfo == null) {	×
92	this.placementInfo = PlacementInfo.create(this.inputIngredient.orElse(Ingredient.of(Items.BUCKET)));	×
93	}
94	return this.placementInfo;	×
95	}
96
97	@Override
98	public RecipeBookCategory recipeBookCategory() {
99	return RegistryEntries.RECIPEBOOKCATEGORY_DRYING_BASIN.get();	×
100	}
101
102	@Override
103	public List<RecipeDisplay> display() {
104	return List.of(new RecipeDisplayDryingBasin(	×
105	this.getInputIngredient().map(Ingredient::display).orElse(SlotDisplay.Empty.INSTANCE),	×
106	this.getInputFluid().orElse(FluidStack.EMPTY),	×
107	this.getOutputItemFirst().<SlotDisplay>map(SlotDisplay.ItemStackSlotDisplay::new).orElse(SlotDisplay.Empty.INSTANCE),	×
108	this.getOutputFluid().orElse(FluidStack.EMPTY),	×
109	new SlotDisplay.ItemSlotDisplay(RegistryEntries.BLOCK_DRYING_BASIN.get().asItem()),	×
110	this.getDuration()	×
111	));
112	}
113	}

CyclopsMC / IntegratedDynamics / 20210191346

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous