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

4.76

/src/main/java/org/cyclops/integrateddynamics/block/BlockEnergyBatteryBase.java

package org.cyclops.integrateddynamics.block;

import net.minecraft.core.BlockPos;
import net.minecraft.world.InteractionResult;
import net.minecraft.world.entity.LivingEntity;
import net.minecraft.world.entity.player.Player;
import net.minecraft.world.item.ItemStack;
import net.minecraft.world.level.Level;
import net.minecraft.world.level.block.Block;
import net.minecraft.world.level.block.entity.BlockEntity;
import net.minecraft.world.level.block.entity.BlockEntityTicker;
import net.minecraft.world.level.block.entity.BlockEntityType;
import net.minecraft.world.level.block.state.BlockState;
import net.minecraft.world.phys.BlockHitResult;
import net.neoforged.neoforge.capabilities.Capabilities;
import net.neoforged.neoforge.transfer.access.ItemAccess;
import net.neoforged.neoforge.transfer.energy.EnergyHandler;
import net.neoforged.neoforge.transfer.transaction.Transaction;
import org.cyclops.cyclopscore.helper.IModHelpers;
import org.cyclops.integrateddynamics.RegistryEntries;
import org.cyclops.integrateddynamics.blockentity.BlockEntityEnergyBattery;
import org.cyclops.integrateddynamics.core.block.BlockContainerCabled;
import org.cyclops.integrateddynamics.core.helper.Helpers;

import javax.annotation.Nullable;
import java.util.Optional;

/**
 * A block that holds energy.
 *
 * @author rubensworks
 */
public abstract class BlockEnergyBatteryBase extends BlockContainerCabled {

    public BlockEnergyBatteryBase(Block.Properties properties) {
        super(properties, BlockEntityEnergyBattery::new);
    }

    @Override
    @Nullable
    public <T extends BlockEntity> BlockEntityTicker<T> getTicker(Level level, BlockState blockState, BlockEntityType<T> blockEntityType) {
        return level.isClientSide() ? null : createTickerHelper(blockEntityType, RegistryEntries.BLOCK_ENTITY_ENERGY_BATTERY.get(), new BlockEntityEnergyBattery.Ticker());
    }

    public abstract boolean isCreative();

    @Override
    public InteractionResult useWithoutItem(BlockState state, Level world, BlockPos pos, Player player,
                                             BlockHitResult blockRayTraceResult) {
        InteractionResult superActionResult = super.useWithoutItem(state, world, pos, player, blockRayTraceResult);
        if (superActionResult.consumesAction()) {
            return superActionResult;
        }

        if (player.getItemInHand(player.getUsedItemHand()).isEmpty()) {
            return IModHelpers.get().getBlockEntityHelpers().get(world, pos, BlockEntityEnergyBattery.class)
                    .<InteractionResult>map(tile -> {
                        player.displayClientMessage(Helpers.getLocalizedEnergyLevel(
                                tile.getEnergyStored(), tile.getMaxEnergyStored()), true);
                        return InteractionResult.SUCCESS;
                    })
                    .orElse(InteractionResult.PASS);
        }

        return InteractionResult.PASS;
    }

    /**
     * Fill an EnergyHandler with all the energy it can hold
     * @param energyStorage EnergyHandler that is to be filled
     */
    public static void fill(EnergyHandler energyStorage){
        int max = energyStorage.getCapacityAsInt();
        int stored = 1;
        while (stored > 0) {
            try (var tx = Transaction.openRoot()) {
                stored = energyStorage.insert(max, tx);
                tx.commit();
            }
        }
    }

    @Override
    public void setPlacedBy(Level world, BlockPos blockPos, BlockState state, LivingEntity placer, ItemStack itemStack) {
        if (!world.isClientSide()) {
            IModHelpers.get().getBlockEntityHelpers().get(world, blockPos, BlockEntityEnergyBattery.class)
                    .ifPresent(tile -> itemStackToTile(itemStack.copy().split(1), tile));
        }
        super.setPlacedBy(world, blockPos, state, placer, itemStack);
    }

    public static void itemStackToTile(ItemStack itemStack, BlockEntityEnergyBattery tile) {
        Optional.ofNullable(itemStack.getCapability(Capabilities.Energy.ITEM, ItemAccess.forStack(itemStack)))
                .ifPresent(energyStorage -> {
                    tile.setEnergyStored(energyStorage.getAmountAsInt());
                    tile.getEnergyHandler().setCapacity(energyStorage.getCapacityAsInt());
                });
    }

}

1	package org.cyclops.integrateddynamics.block;
2
3	import net.minecraft.core.BlockPos;
4	import net.minecraft.world.InteractionResult;
5	import net.minecraft.world.entity.LivingEntity;
6	import net.minecraft.world.entity.player.Player;
7	import net.minecraft.world.item.ItemStack;
8	import net.minecraft.world.level.Level;
9	import net.minecraft.world.level.block.Block;
10	import net.minecraft.world.level.block.entity.BlockEntity;
11	import net.minecraft.world.level.block.entity.BlockEntityTicker;
12	import net.minecraft.world.level.block.entity.BlockEntityType;
13	import net.minecraft.world.level.block.state.BlockState;
14	import net.minecraft.world.phys.BlockHitResult;
15	import net.neoforged.neoforge.capabilities.Capabilities;
16	import net.neoforged.neoforge.transfer.access.ItemAccess;
17	import net.neoforged.neoforge.transfer.energy.EnergyHandler;
18	import net.neoforged.neoforge.transfer.transaction.Transaction;
19	import org.cyclops.cyclopscore.helper.IModHelpers;
20	import org.cyclops.integrateddynamics.RegistryEntries;
21	import org.cyclops.integrateddynamics.blockentity.BlockEntityEnergyBattery;
22	import org.cyclops.integrateddynamics.core.block.BlockContainerCabled;
23	import org.cyclops.integrateddynamics.core.helper.Helpers;
24
25	import javax.annotation.Nullable;
26	import java.util.Optional;
27
28	/**
29	* A block that holds energy.
30	*
31	* @author rubensworks
32	*/
33	public abstract class BlockEnergyBatteryBase extends BlockContainerCabled {
34
35	public BlockEnergyBatteryBase(Block.Properties properties) {
36	super(properties, BlockEntityEnergyBattery::new);	4✔
37	}	1✔
38
39	@Override
40	@Nullable
41	public <T extends BlockEntity> BlockEntityTicker<T> getTicker(Level level, BlockState blockState, BlockEntityType<T> blockEntityType) {
42	return level.isClientSide() ? null : createTickerHelper(blockEntityType, RegistryEntries.BLOCK_ENTITY_ENERGY_BATTERY.get(), new BlockEntityEnergyBattery.Ticker());	×
43	}
44
45	public abstract boolean isCreative();
46
47	@Override
48	public InteractionResult useWithoutItem(BlockState state, Level world, BlockPos pos, Player player,
49	BlockHitResult blockRayTraceResult) {
50	InteractionResult superActionResult = super.useWithoutItem(state, world, pos, player, blockRayTraceResult);	×
51	if (superActionResult.consumesAction()) {	×
52	return superActionResult;	×
53	}
54
55	if (player.getItemInHand(player.getUsedItemHand()).isEmpty()) {	×
56	return IModHelpers.get().getBlockEntityHelpers().get(world, pos, BlockEntityEnergyBattery.class)	×
57	.<InteractionResult>map(tile -> {	×
58	player.displayClientMessage(Helpers.getLocalizedEnergyLevel(	×
59	tile.getEnergyStored(), tile.getMaxEnergyStored()), true);	×
60	return InteractionResult.SUCCESS;	×
61	})
62	.orElse(InteractionResult.PASS);	×
63	}
64
65	return InteractionResult.PASS;	×
66	}
67
68	/**
69	* Fill an EnergyHandler with all the energy it can hold
70	* @param energyStorage EnergyHandler that is to be filled
71	*/
72	public static void fill(EnergyHandler energyStorage){
73	int max = energyStorage.getCapacityAsInt();	×
74	int stored = 1;	×
75	while (stored > 0) {	×
76	try (var tx = Transaction.openRoot()) {	×
77	stored = energyStorage.insert(max, tx);	×
78	tx.commit();	×
79	}
80	}
81	}	×
82
83	@Override
84	public void setPlacedBy(Level world, BlockPos blockPos, BlockState state, LivingEntity placer, ItemStack itemStack) {
85	if (!world.isClientSide()) {	×
86	IModHelpers.get().getBlockEntityHelpers().get(world, blockPos, BlockEntityEnergyBattery.class)	×
87	.ifPresent(tile -> itemStackToTile(itemStack.copy().split(1), tile));	×
88	}
89	super.setPlacedBy(world, blockPos, state, placer, itemStack);	×
90	}	×
91
92	public static void itemStackToTile(ItemStack itemStack, BlockEntityEnergyBattery tile) {
93	Optional.ofNullable(itemStack.getCapability(Capabilities.Energy.ITEM, ItemAccess.forStack(itemStack)))	×
94	.ifPresent(energyStorage -> {	×
95	tile.setEnergyStored(energyStorage.getAmountAsInt());	×
96	tile.getEnergyHandler().setCapacity(energyStorage.getCapacityAsInt());	×
97	});	×
98	}	×
99
100	}

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