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

5.79

/src/main/java/org/cyclops/integrateddynamics/blockentity/BlockEntitySqueezer.java

package org.cyclops.integrateddynamics.blockentity;

import com.google.common.collect.Lists;
import lombok.Getter;
import net.minecraft.core.BlockPos;
import net.minecraft.core.Direction;
import net.minecraft.world.Containers;
import net.minecraft.world.item.ItemStack;
import net.minecraft.world.item.crafting.CraftingInput;
import net.minecraft.world.item.crafting.RecipeHolder;
import net.minecraft.world.item.crafting.RecipeType;
import net.minecraft.world.level.Level;
import net.minecraft.world.level.block.entity.BlockEntityType;
import net.minecraft.world.level.block.state.BlockState;
import net.minecraft.world.level.storage.ValueInput;
import net.minecraft.world.level.storage.ValueOutput;
import net.neoforged.neoforge.capabilities.Capabilities;
import net.neoforged.neoforge.fluids.FluidStack;
import net.neoforged.neoforge.transfer.ResourceHandler;
import net.neoforged.neoforge.transfer.ResourceHandlerUtil;
import net.neoforged.neoforge.transfer.fluid.FluidResource;
import net.neoforged.neoforge.transfer.item.ItemResource;
import net.neoforged.neoforge.transfer.item.VanillaContainerWrapper;
import net.neoforged.neoforge.transfer.transaction.Transaction;
import org.cyclops.cyclopscore.blockentity.BlockEntityTickerDelayed;
import org.cyclops.cyclopscore.blockentity.CyclopsBlockEntity;
import org.cyclops.cyclopscore.capability.registrar.BlockEntityCapabilityRegistrar;
import org.cyclops.cyclopscore.datastructure.SingleCache;
import org.cyclops.cyclopscore.fluid.SingleUseTank;
import org.cyclops.cyclopscore.helper.IModHelpers;
import org.cyclops.cyclopscore.helper.IModHelpersNeoForge;
import org.cyclops.cyclopscore.inventory.SimpleInventory;
import org.cyclops.cyclopscore.inventory.SimpleInventoryState;
import org.cyclops.cyclopscore.persist.nbt.NBTPersist;
import org.cyclops.integrateddynamics.RegistryEntries;
import org.cyclops.integrateddynamics.block.BlockSqueezer;
import org.cyclops.integrateddynamics.core.recipe.handler.RecipeHandlerSqueezer;
import org.cyclops.integrateddynamics.core.recipe.type.RecipeSqueezer;

import java.util.Arrays;
import java.util.Optional;
import java.util.function.Supplier;

/**
 * A part entity for squeezing stuff.
 * @author rubensworks
 */
public class BlockEntitySqueezer extends CyclopsBlockEntity {

    private final SimpleInventory inventory;
    private final SingleUseTank tank;

    @NBTPersist
    @Getter
    private int itemHeight = 1;

    private SingleCache<ItemStack, Optional<RecipeHolder<RecipeSqueezer>>> recipeCache;

    public BlockEntitySqueezer(BlockPos blockPos, BlockState blockState) {
        super(RegistryEntries.BLOCK_ENTITY_SQUEEZER.get(), blockPos, blockState);

        // Create inventory and tank
        this.inventory = new SimpleInventory(1, 1) {
            @Override
            public boolean canPlaceItem(int slot, ItemStack itemStack) {
                return getLevel().getBlockState(getBlockPos()).getValue(BlockSqueezer.HEIGHT) == 1
                        && getItem(0).isEmpty() && super.canPlaceItem(slot, itemStack);
            }

            @Override
            public void setItem(int slotId, ItemStack itemstack) {
                super.setItem(slotId, itemstack);
                itemHeight = 1;
                sendUpdate();
            }
        };
        this.tank = new SingleUseTank(IModHelpersNeoForge.get().getFluidHelpers().getBucketVolume());

        // Add dirty mark listeners to inventory and tank
        this.inventory.addDirtyMarkListener(this::sendUpdate);
        this.tank.addDirtyMarkListener(this.inventory::setChanged);

        // Efficient cache to retrieve the current craftable recipe.
        recipeCache = new SingleCache<>(
                new SingleCache.ICacheUpdater<ItemStack, Optional<RecipeHolder<RecipeSqueezer>>>() {
                    @Override
                    public Optional<RecipeHolder<RecipeSqueezer>> getNewValue(ItemStack key) {
                        return IModHelpers.get().getCraftingHelpers().findRecipe(getRegistry(), CraftingInput.of(1, 1, Lists.newArrayList(key)), getLevel());
                    }

                    @Override
                    public boolean isKeyEqual(ItemStack cacheKey, ItemStack newKey) {
                        return ItemStack.matches(cacheKey, newKey);
                    }
                });
    }

    public static class CapabilityRegistrar extends BlockEntityCapabilityRegistrar<BlockEntitySqueezer> {
        public CapabilityRegistrar(Supplier<BlockEntityType<? extends BlockEntitySqueezer>> blockEntityType) {
            super(blockEntityType);
        }

        @Override
        public void populate() {
            add(
                    net.neoforged.neoforge.capabilities.Capabilities.Item.BLOCK,
                    (blockEntity, direction) -> VanillaContainerWrapper.of(blockEntity.getInventory())
            );
            add(
                    org.cyclops.commoncapabilities.api.capability.Capabilities.InventoryState.BLOCK,
                    (blockEntity, direction) -> new SimpleInventoryState(blockEntity.getInventory())
            );
            add(
                    net.neoforged.neoforge.capabilities.Capabilities.Fluid.BLOCK,
                    (blockEntity, direction) -> blockEntity.getTank()
            );
            add(
                    org.cyclops.commoncapabilities.api.capability.Capabilities.RecipeHandler.BLOCK,
                    (blockEntity, direction) -> new RecipeHandlerSqueezer<>(blockEntity::getLevel, RegistryEntries.RECIPETYPE_SQUEEZER.get())
            );
        }
    }

    public SimpleInventory getInventory() {
        return inventory;
    }

    public SingleUseTank getTank() {
        return tank;
    }

    @Override
    public void read(ValueInput input) {
        inventory.readFromNBT(input, "inventory");
        tank.deserialize(input, "tank");
        super.read(input);
    }

    @Override
    public void saveAdditional(ValueOutput output) {
        inventory.writeToNBT(output, "inventory");
        tank.serialize(output, "tank");
        super.saveAdditional(output);
    }

    protected RecipeType<RecipeSqueezer> getRegistry() {
        return RegistryEntries.RECIPETYPE_SQUEEZER.get();
    }

    public Optional<RecipeHolder<RecipeSqueezer>> getCurrentRecipe() {
        return recipeCache.get(getInventory().getItem(0).copy());
    }

    public void setItemHeight(int itemHeight) {
        this.itemHeight = itemHeight;
        sendUpdate();
        getInventory().setChanged();
    }

    @Override
    public void preRemoveSideEffects(BlockPos pos, BlockState state) {
        super.preRemoveSideEffects(pos, state);
        Containers.dropContents(level, pos, this.getInventory());
    }

    public static class Ticker extends BlockEntityTickerDelayed<BlockEntitySqueezer> {
        @Override
        protected void update(Level level, BlockPos pos, BlockState blockState, BlockEntitySqueezer blockEntity) {
            super.update(level, pos, blockState, blockEntity);

            if(!blockEntity.getTank().isEmpty()) {
                Direction.Axis axis = blockState.getValue(BlockSqueezer.AXIS);
                Arrays.stream(Direction.AxisDirection.values())
                        .map(axisDirection -> Direction.get(axisDirection, axis))
                        .forEach(side -> {
                            if (!blockEntity.getTank().isEmpty()) {
                                IModHelpersNeoForge.get().getCapabilityHelpers().getCapability(level, pos.relative(side), side.getOpposite(), net.neoforged.neoforge.capabilities.Capabilities.Fluid.BLOCK)
                                        .ifPresent(handler -> {
                                            FluidStack fluidStack = new FluidStack(blockEntity.getTank().getFluid().getFluid(),
                                                    Math.min(100, blockEntity.getTank().getFluidAmount()));
                                            ResourceHandlerUtil.move(blockEntity.getTank(), handler, f -> f.matches(fluidStack), fluidStack.getAmount(), null);
                                        });
                            }
                        });
            } else {
                if (blockEntity.itemHeight == 7) {
                    Optional<RecipeHolder<RecipeSqueezer>> recipeOptional = blockEntity.getCurrentRecipe();
                    if (recipeOptional.isPresent()) {
                        RecipeSqueezer recipe = recipeOptional.get().value();
                        blockEntity.getInventory().setItem(0, ItemStack.EMPTY);
                        for (RecipeSqueezer.IngredientChance itemStackChance : recipe.getOutputItems()) {
                            if (itemStackChance.getChance() == 1.0F || itemStackChance.getChance() >= level.random.nextFloat()) {
                                ItemStack resultStack = itemStackChance.getIngredientFirst().copy();
                                for (Direction side : Direction.values()) {
                                    if (!resultStack.isEmpty() && side != Direction.UP) {
                                        ResourceHandler<ItemResource> itemHandler = IModHelpersNeoForge.get().getCapabilityHelpers().getCapability(level, pos.relative(side), side.getOpposite(), Capabilities.Item.BLOCK).orElse(null);
                                        if (itemHandler != null) {
                                            try (var tx = Transaction.openRoot()) {
                                                int inserted = itemHandler.insert(ItemResource.of(resultStack), resultStack.getCount(), tx);
                                                tx.commit();
                                                resultStack.shrink(inserted);
                                            }
                                        }
                                    }
                                }
                                if (!resultStack.isEmpty()) {
                                    IModHelpers.get().getItemStackHelpers().spawnItemStack(level, pos, resultStack);
                                }
                            }
                        }
                        if (recipe.getOutputFluid().isPresent()) {
                            try (var tx = Transaction.openRoot()) {
                                FluidStack fluidStack = recipe.getOutputFluid().get();
                                blockEntity.getTank().insert(FluidResource.of(fluidStack), fluidStack.getAmount(), tx);
                                tx.commit();
                            }
                        }
                    }
                }
            }
        }
    }
}

1	package org.cyclops.integrateddynamics.blockentity;
2
3	import com.google.common.collect.Lists;
4	import lombok.Getter;
5	import net.minecraft.core.BlockPos;
6	import net.minecraft.core.Direction;
7	import net.minecraft.world.Containers;
8	import net.minecraft.world.item.ItemStack;
9	import net.minecraft.world.item.crafting.CraftingInput;
10	import net.minecraft.world.item.crafting.RecipeHolder;
11	import net.minecraft.world.item.crafting.RecipeType;
12	import net.minecraft.world.level.Level;
13	import net.minecraft.world.level.block.entity.BlockEntityType;
14	import net.minecraft.world.level.block.state.BlockState;
15	import net.minecraft.world.level.storage.ValueInput;
16	import net.minecraft.world.level.storage.ValueOutput;
17	import net.neoforged.neoforge.capabilities.Capabilities;
18	import net.neoforged.neoforge.fluids.FluidStack;
19	import net.neoforged.neoforge.transfer.ResourceHandler;
20	import net.neoforged.neoforge.transfer.ResourceHandlerUtil;
21	import net.neoforged.neoforge.transfer.fluid.FluidResource;
22	import net.neoforged.neoforge.transfer.item.ItemResource;
23	import net.neoforged.neoforge.transfer.item.VanillaContainerWrapper;
24	import net.neoforged.neoforge.transfer.transaction.Transaction;
25	import org.cyclops.cyclopscore.blockentity.BlockEntityTickerDelayed;
26	import org.cyclops.cyclopscore.blockentity.CyclopsBlockEntity;
27	import org.cyclops.cyclopscore.capability.registrar.BlockEntityCapabilityRegistrar;
28	import org.cyclops.cyclopscore.datastructure.SingleCache;
29	import org.cyclops.cyclopscore.fluid.SingleUseTank;
30	import org.cyclops.cyclopscore.helper.IModHelpers;
31	import org.cyclops.cyclopscore.helper.IModHelpersNeoForge;
32	import org.cyclops.cyclopscore.inventory.SimpleInventory;
33	import org.cyclops.cyclopscore.inventory.SimpleInventoryState;
34	import org.cyclops.cyclopscore.persist.nbt.NBTPersist;
35	import org.cyclops.integrateddynamics.RegistryEntries;
36	import org.cyclops.integrateddynamics.block.BlockSqueezer;
37	import org.cyclops.integrateddynamics.core.recipe.handler.RecipeHandlerSqueezer;
38	import org.cyclops.integrateddynamics.core.recipe.type.RecipeSqueezer;
39
40	import java.util.Arrays;
41	import java.util.Optional;
42	import java.util.function.Supplier;
43
44	/**
45	* A part entity for squeezing stuff.
46	* @author rubensworks
47	*/
48	public class BlockEntitySqueezer extends CyclopsBlockEntity {
49
50	private final SimpleInventory inventory;
51	private final SingleUseTank tank;
52
53	@NBTPersist	×
54	@Getter	×
55	private int itemHeight = 1;
56
57	private SingleCache<ItemStack, Optional<RecipeHolder<RecipeSqueezer>>> recipeCache;
58
59	public BlockEntitySqueezer(BlockPos blockPos, BlockState blockState) {
60	super(RegistryEntries.BLOCK_ENTITY_SQUEEZER.get(), blockPos, blockState);	×
61
62	// Create inventory and tank
63	this.inventory = new SimpleInventory(1, 1) {	×
64	@Override
65	public boolean canPlaceItem(int slot, ItemStack itemStack) {
66	return getLevel().getBlockState(getBlockPos()).getValue(BlockSqueezer.HEIGHT) == 1	×
67	&& getItem(0).isEmpty() && super.canPlaceItem(slot, itemStack);	×
68	}
69
70	@Override
71	public void setItem(int slotId, ItemStack itemstack) {
72	super.setItem(slotId, itemstack);	×
73	itemHeight = 1;	×
74	sendUpdate();	×
75	}	×
76	};
77	this.tank = new SingleUseTank(IModHelpersNeoForge.get().getFluidHelpers().getBucketVolume());	×
78
79	// Add dirty mark listeners to inventory and tank
80	this.inventory.addDirtyMarkListener(this::sendUpdate);	×
81	this.tank.addDirtyMarkListener(this.inventory::setChanged);	×
82
83	// Efficient cache to retrieve the current craftable recipe.
84	recipeCache = new SingleCache<>(	×
85	new SingleCache.ICacheUpdater<ItemStack, Optional<RecipeHolder<RecipeSqueezer>>>() {	×
86	@Override
87	public Optional<RecipeHolder<RecipeSqueezer>> getNewValue(ItemStack key) {
88	return IModHelpers.get().getCraftingHelpers().findRecipe(getRegistry(), CraftingInput.of(1, 1, Lists.newArrayList(key)), getLevel());	×
89	}
90
91	@Override
92	public boolean isKeyEqual(ItemStack cacheKey, ItemStack newKey) {
93	return ItemStack.matches(cacheKey, newKey);	×
94	}
95	});
96	}	×
97
98	public static class CapabilityRegistrar extends BlockEntityCapabilityRegistrar<BlockEntitySqueezer> {
99	public CapabilityRegistrar(Supplier<BlockEntityType<? extends BlockEntitySqueezer>> blockEntityType) {
100	super(blockEntityType);	3✔
101	}	1✔
102
103	@Override
104	public void populate() {
105	add(	4✔
106	net.neoforged.neoforge.capabilities.Capabilities.Item.BLOCK,
107	(blockEntity, direction) -> VanillaContainerWrapper.of(blockEntity.getInventory())	×
108	);
109	add(	4✔
110	org.cyclops.commoncapabilities.api.capability.Capabilities.InventoryState.BLOCK,
111	(blockEntity, direction) -> new SimpleInventoryState(blockEntity.getInventory())	×
112	);
113	add(	4✔
114	net.neoforged.neoforge.capabilities.Capabilities.Fluid.BLOCK,
115	(blockEntity, direction) -> blockEntity.getTank()	×
116	);
117	add(	4✔
118	org.cyclops.commoncapabilities.api.capability.Capabilities.RecipeHandler.BLOCK,
119	(blockEntity, direction) -> new RecipeHandlerSqueezer<>(blockEntity::getLevel, RegistryEntries.RECIPETYPE_SQUEEZER.get())	×
120	);
121	}	1✔
122	}
123
124	public SimpleInventory getInventory() {
125	return inventory;	×
126	}
127
128	public SingleUseTank getTank() {
129	return tank;	×
130	}
131
132	@Override
133	public void read(ValueInput input) {
134	inventory.readFromNBT(input, "inventory");	×
135	tank.deserialize(input, "tank");	×
136	super.read(input);	×
137	}	×
138
139	@Override
140	public void saveAdditional(ValueOutput output) {
141	inventory.writeToNBT(output, "inventory");	×
142	tank.serialize(output, "tank");	×
143	super.saveAdditional(output);	×
144	}	×
145
146	protected RecipeType<RecipeSqueezer> getRegistry() {
147	return RegistryEntries.RECIPETYPE_SQUEEZER.get();	×
148	}
149
150	public Optional<RecipeHolder<RecipeSqueezer>> getCurrentRecipe() {
151	return recipeCache.get(getInventory().getItem(0).copy());	×
152	}
153
154	public void setItemHeight(int itemHeight) {
155	this.itemHeight = itemHeight;	×
156	sendUpdate();	×
157	getInventory().setChanged();	×
158	}	×
159
160	@Override
161	public void preRemoveSideEffects(BlockPos pos, BlockState state) {
162	super.preRemoveSideEffects(pos, state);	×
163	Containers.dropContents(level, pos, this.getInventory());	×
164	}	×
165
166	public static class Ticker extends BlockEntityTickerDelayed<BlockEntitySqueezer> {	×
167	@Override
168	protected void update(Level level, BlockPos pos, BlockState blockState, BlockEntitySqueezer blockEntity) {
169	super.update(level, pos, blockState, blockEntity);	×
170
171	if(!blockEntity.getTank().isEmpty()) {	×
172	Direction.Axis axis = blockState.getValue(BlockSqueezer.AXIS);	×
173	Arrays.stream(Direction.AxisDirection.values())	×
174	.map(axisDirection -> Direction.get(axisDirection, axis))	×
175	.forEach(side -> {	×
176	if (!blockEntity.getTank().isEmpty()) {	×
177	IModHelpersNeoForge.get().getCapabilityHelpers().getCapability(level, pos.relative(side), side.getOpposite(), net.neoforged.neoforge.capabilities.Capabilities.Fluid.BLOCK)	×
178	.ifPresent(handler -> {	×
179	FluidStack fluidStack = new FluidStack(blockEntity.getTank().getFluid().getFluid(),	×
180	Math.min(100, blockEntity.getTank().getFluidAmount()));	×
181	ResourceHandlerUtil.move(blockEntity.getTank(), handler, f -> f.matches(fluidStack), fluidStack.getAmount(), null);	×
182	});	×
183	}
184	});	×
185	} else {	×
186	if (blockEntity.itemHeight == 7) {	×
187	Optional<RecipeHolder<RecipeSqueezer>> recipeOptional = blockEntity.getCurrentRecipe();	×
188	if (recipeOptional.isPresent()) {	×
189	RecipeSqueezer recipe = recipeOptional.get().value();	×
190	blockEntity.getInventory().setItem(0, ItemStack.EMPTY);	×
191	for (RecipeSqueezer.IngredientChance itemStackChance : recipe.getOutputItems()) {	×
192	if (itemStackChance.getChance() == 1.0F \|\| itemStackChance.getChance() >= level.random.nextFloat()) {	×
193	ItemStack resultStack = itemStackChance.getIngredientFirst().copy();	×
194	for (Direction side : Direction.values()) {	×
195	if (!resultStack.isEmpty() && side != Direction.UP) {	×
196	ResourceHandler<ItemResource> itemHandler = IModHelpersNeoForge.get().getCapabilityHelpers().getCapability(level, pos.relative(side), side.getOpposite(), Capabilities.Item.BLOCK).orElse(null);	×
197	if (itemHandler != null) {	×
198	try (var tx = Transaction.openRoot()) {	×
199	int inserted = itemHandler.insert(ItemResource.of(resultStack), resultStack.getCount(), tx);	×
200	tx.commit();	×
201	resultStack.shrink(inserted);	×
202	}
203	}
204	}
205	}
206	if (!resultStack.isEmpty()) {	×
207	IModHelpers.get().getItemStackHelpers().spawnItemStack(level, pos, resultStack);	×
208	}
209	}
210	}	×
211	if (recipe.getOutputFluid().isPresent()) {	×
212	try (var tx = Transaction.openRoot()) {	×
213	FluidStack fluidStack = recipe.getOutputFluid().get();	×
214	blockEntity.getTank().insert(FluidResource.of(fluidStack), fluidStack.getAmount(), tx);	×
215	tx.commit();	×
216	}
217	}
218	}
219	}
220	}
221	}	×
222	}
223	}

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