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

6.25

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

package org.cyclops.integrateddynamics.blockentity;

import net.minecraft.core.BlockPos;
import net.minecraft.network.chat.Component;
import net.minecraft.world.MenuProvider;
import net.minecraft.world.entity.player.Inventory;
import net.minecraft.world.entity.player.Player;
import net.minecraft.world.inventory.AbstractContainerMenu;
import net.minecraft.world.item.ItemStack;
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.neoforged.neoforge.server.ServerLifecycleHooks;
import net.neoforged.neoforge.transfer.energy.EnergyHandler;
import net.neoforged.neoforge.transfer.energy.SimpleEnergyHandler;
import org.cyclops.cyclopscore.datastructure.DataSlotSupplied;
import org.cyclops.cyclopscore.datastructure.DimPos;
import org.cyclops.cyclopscore.helper.IModHelpers;
import org.cyclops.cyclopscore.persist.nbt.NBTPersist;
import org.cyclops.integrateddynamics.Capabilities;
import org.cyclops.integrateddynamics.RegistryEntries;
import org.cyclops.integrateddynamics.api.network.IEnergyNetwork;
import org.cyclops.integrateddynamics.api.network.INetworkElement;
import org.cyclops.integrateddynamics.api.network.INetworkElementProvider;
import org.cyclops.integrateddynamics.api.network.IPositionedAddonsNetwork;
import org.cyclops.integrateddynamics.block.BlockCoalGenerator;
import org.cyclops.integrateddynamics.capability.networkelementprovider.NetworkElementProviderSingleton;
import org.cyclops.integrateddynamics.core.blockentity.BlockEntityCableConnectableInventory;
import org.cyclops.integrateddynamics.core.helper.EnergyHelpers;
import org.cyclops.integrateddynamics.core.helper.NetworkHelpers;
import org.cyclops.integrateddynamics.inventory.container.ContainerCoalGenerator;
import org.cyclops.integrateddynamics.network.CoalGeneratorNetworkElement;

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

/**
 * A part entity for the coal energy generator.
 * @author rubensworks
 */
public class BlockEntityCoalGenerator extends BlockEntityCableConnectableInventory implements MenuProvider {

    public static final int INVENTORY_SIZE = 1;
    public static final int MAX_PROGRESS = 13;
    public static final int ENERGY_PER_TICK = 20;
    public static final int SLOT_FUEL = 0;

    @NBTPersist
    private int currentlyBurningMax;
    @NBTPersist
    private int currentlyBurning;
    private final EnergyHandler energyHandler;

    public BlockEntityCoalGenerator(BlockPos blockPos, BlockState blockState) {
        super(RegistryEntries.BLOCK_ENTITY_COAL_GENERATOR.get(), blockPos, blockState, BlockEntityCoalGenerator.INVENTORY_SIZE, 64);
        this.energyHandler = new SimpleEnergyHandler(0);
    }

    public static class CapabilityRegistrar extends BlockEntityCableConnectableInventory.CapabilityRegistrar<BlockEntityCoalGenerator> {
        public CapabilityRegistrar(Supplier<BlockEntityType<? extends BlockEntityCoalGenerator>> blockEntityType) {
            super(blockEntityType);
        }

        @Override
        public void populate() {
            super.populate();

            add(
                    Capabilities.NetworkElementProvider.BLOCK,
                    (blockEntity, context) -> blockEntity.getNetworkElementProvider()
            );
            add(
                    net.neoforged.neoforge.capabilities.Capabilities.Energy.BLOCK,
                    (blockEntity, context) -> blockEntity.getEnergyHandler()
            );
        }
    }

    @Override
    public INetworkElementProvider getNetworkElementProvider() {
        return new NetworkElementProviderSingleton() {
            @Override
            public INetworkElement createNetworkElement(Level world, BlockPos blockPos) {
                return new CoalGeneratorNetworkElement(DimPos.of(world, blockPos));
            }
        };
    }

    public EnergyHandler getEnergyHandler() {
        return energyHandler;
    }

    public Optional<IEnergyNetwork> getEnergyNetwork() {
        return NetworkHelpers.getEnergyNetwork(getNetwork());
    }

    public void updateBlockState() {
        boolean wasBurning = getLevel().getBlockState(getBlockPos()).getValue(BlockCoalGenerator.LIT);
        boolean isBurning = isBurning();
        if (isBurning != wasBurning) {
            getLevel().setBlockAndUpdate(getBlockPos(),
                    getLevel().getBlockState(getBlockPos()).setValue(BlockCoalGenerator.LIT, isBurning));
        }
    }

    public int getProgress() {
        float current = currentlyBurning;
        float max = currentlyBurningMax;
        if (max == 0) {
            return -1;
        }
        return Math.round((current / max) * (float) MAX_PROGRESS);
    }

    public boolean isBurning() {
        return currentlyBurning < currentlyBurningMax;
    }

    public boolean canAddEnergy(int energy) {
        IEnergyNetwork network = getEnergyNetwork().orElse(null);
        if(network != null && network.getChannel(IPositionedAddonsNetwork.DEFAULT_CHANNEL).insert((long) energy, true) == 0) {
            return true;
        }
        return addEnergyFe(energy, true) == energy;
    }

    protected int addEnergy(int energy) {
        IEnergyNetwork network = getEnergyNetwork().orElse(null);
        int toFill = energy;
        if(network != null) {
            toFill = IModHelpers.get().getBaseHelpers().castSafe(network.getChannel(IPositionedAddonsNetwork.DEFAULT_CHANNEL).insert((long) toFill, false));
        }
        if(toFill > 0) {
            toFill -= addEnergyFe(toFill, false);
        }
        return energy - toFill;
    }

    protected int addEnergyFe(int energy, boolean simulate) {
        return EnergyHelpers.fillNeigbours(getLevel(), getBlockPos(), energy, simulate);
    }

    public static int getFuelTime(ItemStack itemStack) {
        return itemStack.getBurnTime(RecipeType.SMELTING, ServerLifecycleHooks.getCurrentServer().fuelValues());
    }

    @Override
    public Component getDisplayName() {
        return Component.translatable("block.integrateddynamics.coal_generator");
    }

    @Nullable
    @Override
    public AbstractContainerMenu createMenu(int id, Inventory playerInventory, Player playerEntity) {
        return new ContainerCoalGenerator(id, playerInventory, this.getInventory(), new DataSlotSupplied(this::getProgress));
    }

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

            if((!blockEntity.getInventory().getItem(SLOT_FUEL).isEmpty() || blockEntity.isBurning()) && blockEntity.canAddEnergy(ENERGY_PER_TICK)) {
                if (blockEntity.isBurning()) {
                    if (blockEntity.currentlyBurning++ >= blockEntity.currentlyBurningMax) {
                        blockEntity.currentlyBurning = 0;
                        blockEntity.currentlyBurningMax = 0;
                    }
                    int toFill = ENERGY_PER_TICK;
                    blockEntity.addEnergy(toFill);
                    blockEntity.setChanged();
                }
                if (!blockEntity.isBurning()) {
                    ItemStack fuel;
                    if (getFuelTime(blockEntity.getInventory().getItem(SLOT_FUEL)) > 0
                            && !(fuel = blockEntity.getInventory().removeItem(SLOT_FUEL, 1)).isEmpty()) {
                        if(blockEntity.getInventory().getItem(SLOT_FUEL).isEmpty()) {
                            blockEntity.getInventory().setItem(SLOT_FUEL, fuel.getItem().getCraftingRemainder(fuel));
                        }
                        blockEntity.currentlyBurningMax = getFuelTime(fuel);
                        blockEntity.currentlyBurning = 0;
                        blockEntity.setChanged();
                    }
                    blockEntity.updateBlockState();
                }
            }
        }
    }
}

1	package org.cyclops.integrateddynamics.blockentity;
2
3	import net.minecraft.core.BlockPos;
4	import net.minecraft.network.chat.Component;
5	import net.minecraft.world.MenuProvider;
6	import net.minecraft.world.entity.player.Inventory;
7	import net.minecraft.world.entity.player.Player;
8	import net.minecraft.world.inventory.AbstractContainerMenu;
9	import net.minecraft.world.item.ItemStack;
10	import net.minecraft.world.item.crafting.RecipeType;
11	import net.minecraft.world.level.Level;
12	import net.minecraft.world.level.block.entity.BlockEntityType;
13	import net.minecraft.world.level.block.state.BlockState;
14	import net.neoforged.neoforge.server.ServerLifecycleHooks;
15	import net.neoforged.neoforge.transfer.energy.EnergyHandler;
16	import net.neoforged.neoforge.transfer.energy.SimpleEnergyHandler;
17	import org.cyclops.cyclopscore.datastructure.DataSlotSupplied;
18	import org.cyclops.cyclopscore.datastructure.DimPos;
19	import org.cyclops.cyclopscore.helper.IModHelpers;
20	import org.cyclops.cyclopscore.persist.nbt.NBTPersist;
21	import org.cyclops.integrateddynamics.Capabilities;
22	import org.cyclops.integrateddynamics.RegistryEntries;
23	import org.cyclops.integrateddynamics.api.network.IEnergyNetwork;
24	import org.cyclops.integrateddynamics.api.network.INetworkElement;
25	import org.cyclops.integrateddynamics.api.network.INetworkElementProvider;
26	import org.cyclops.integrateddynamics.api.network.IPositionedAddonsNetwork;
27	import org.cyclops.integrateddynamics.block.BlockCoalGenerator;
28	import org.cyclops.integrateddynamics.capability.networkelementprovider.NetworkElementProviderSingleton;
29	import org.cyclops.integrateddynamics.core.blockentity.BlockEntityCableConnectableInventory;
30	import org.cyclops.integrateddynamics.core.helper.EnergyHelpers;
31	import org.cyclops.integrateddynamics.core.helper.NetworkHelpers;
32	import org.cyclops.integrateddynamics.inventory.container.ContainerCoalGenerator;
33	import org.cyclops.integrateddynamics.network.CoalGeneratorNetworkElement;
34
35	import javax.annotation.Nullable;
36	import java.util.Optional;
37	import java.util.function.Supplier;
38
39	/**
40	* A part entity for the coal energy generator.
41	* @author rubensworks
42	*/
43	public class BlockEntityCoalGenerator extends BlockEntityCableConnectableInventory implements MenuProvider {
44
45	public static final int INVENTORY_SIZE = 1;
46	public static final int MAX_PROGRESS = 13;
47	public static final int ENERGY_PER_TICK = 20;
48	public static final int SLOT_FUEL = 0;
49
50	@NBTPersist
51	private int currentlyBurningMax;
52	@NBTPersist
53	private int currentlyBurning;
54	private final EnergyHandler energyHandler;
55
56	public BlockEntityCoalGenerator(BlockPos blockPos, BlockState blockState) {
57	super(RegistryEntries.BLOCK_ENTITY_COAL_GENERATOR.get(), blockPos, blockState, BlockEntityCoalGenerator.INVENTORY_SIZE, 64);	×
58	this.energyHandler = new SimpleEnergyHandler(0);	×
59	}	×
60
61	public static class CapabilityRegistrar extends BlockEntityCableConnectableInventory.CapabilityRegistrar<BlockEntityCoalGenerator> {
62	public CapabilityRegistrar(Supplier<BlockEntityType<? extends BlockEntityCoalGenerator>> blockEntityType) {
63	super(blockEntityType);	3✔
64	}	1✔
65
66	@Override
67	public void populate() {
68	super.populate();	2✔
69
70	add(	4✔
71	Capabilities.NetworkElementProvider.BLOCK,
72	(blockEntity, context) -> blockEntity.getNetworkElementProvider()	×
73	);
74	add(	4✔
75	net.neoforged.neoforge.capabilities.Capabilities.Energy.BLOCK,
76	(blockEntity, context) -> blockEntity.getEnergyHandler()	×
77	);
78	}	1✔
79	}
80
81	@Override
82	public INetworkElementProvider getNetworkElementProvider() {
83	return new NetworkElementProviderSingleton() {	×
84	@Override
85	public INetworkElement createNetworkElement(Level world, BlockPos blockPos) {
86	return new CoalGeneratorNetworkElement(DimPos.of(world, blockPos));	×
87	}
88	};
89	}
90
91	public EnergyHandler getEnergyHandler() {
92	return energyHandler;	×
93	}
94
95	public Optional<IEnergyNetwork> getEnergyNetwork() {
96	return NetworkHelpers.getEnergyNetwork(getNetwork());	×
97	}
98
99	public void updateBlockState() {
100	boolean wasBurning = getLevel().getBlockState(getBlockPos()).getValue(BlockCoalGenerator.LIT);	×
101	boolean isBurning = isBurning();	×
102	if (isBurning != wasBurning) {	×
103	getLevel().setBlockAndUpdate(getBlockPos(),	×
104	getLevel().getBlockState(getBlockPos()).setValue(BlockCoalGenerator.LIT, isBurning));	×
105	}
106	}	×
107
108	public int getProgress() {
109	float current = currentlyBurning;	×
110	float max = currentlyBurningMax;	×
111	if (max == 0) {	×
112	return -1;	×
113	}
114	return Math.round((current / max) * (float) MAX_PROGRESS);	×
115	}
116
117	public boolean isBurning() {
118	return currentlyBurning < currentlyBurningMax;	×
119	}
120
121	public boolean canAddEnergy(int energy) {
122	IEnergyNetwork network = getEnergyNetwork().orElse(null);	×
123	if(network != null && network.getChannel(IPositionedAddonsNetwork.DEFAULT_CHANNEL).insert((long) energy, true) == 0) {	×
124	return true;	×
125	}
126	return addEnergyFe(energy, true) == energy;	×
127	}
128
129	protected int addEnergy(int energy) {
130	IEnergyNetwork network = getEnergyNetwork().orElse(null);	×
131	int toFill = energy;	×
132	if(network != null) {	×
133	toFill = IModHelpers.get().getBaseHelpers().castSafe(network.getChannel(IPositionedAddonsNetwork.DEFAULT_CHANNEL).insert((long) toFill, false));	×
134	}
135	if(toFill > 0) {	×
136	toFill -= addEnergyFe(toFill, false);	×
137	}
138	return energy - toFill;	×
139	}
140
141	protected int addEnergyFe(int energy, boolean simulate) {
142	return EnergyHelpers.fillNeigbours(getLevel(), getBlockPos(), energy, simulate);	×
143	}
144
145	public static int getFuelTime(ItemStack itemStack) {
146	return itemStack.getBurnTime(RecipeType.SMELTING, ServerLifecycleHooks.getCurrentServer().fuelValues());	×
147	}
148
149	@Override
150	public Component getDisplayName() {
151	return Component.translatable("block.integrateddynamics.coal_generator");	×
152	}
153
154	@Nullable
155	@Override
156	public AbstractContainerMenu createMenu(int id, Inventory playerInventory, Player playerEntity) {
157	return new ContainerCoalGenerator(id, playerInventory, this.getInventory(), new DataSlotSupplied(this::getProgress));	×
158	}
159
160	public static class Ticker extends BlockEntityCableConnectableInventory.Ticker<BlockEntityCoalGenerator> {	×
161	@Override
162	protected void update(Level level, BlockPos pos, BlockState blockState, BlockEntityCoalGenerator blockEntity) {
163	super.update(level, pos, blockState, blockEntity);	×
164
165	if((!blockEntity.getInventory().getItem(SLOT_FUEL).isEmpty() \|\| blockEntity.isBurning()) && blockEntity.canAddEnergy(ENERGY_PER_TICK)) {	×
166	if (blockEntity.isBurning()) {	×
167	if (blockEntity.currentlyBurning++ >= blockEntity.currentlyBurningMax) {	×
168	blockEntity.currentlyBurning = 0;	×
169	blockEntity.currentlyBurningMax = 0;	×
170	}
171	int toFill = ENERGY_PER_TICK;	×
172	blockEntity.addEnergy(toFill);	×
173	blockEntity.setChanged();	×
174	}
175	if (!blockEntity.isBurning()) {	×
176	ItemStack fuel;
177	if (getFuelTime(blockEntity.getInventory().getItem(SLOT_FUEL)) > 0	×
178	&& !(fuel = blockEntity.getInventory().removeItem(SLOT_FUEL, 1)).isEmpty()) {	×
179	if(blockEntity.getInventory().getItem(SLOT_FUEL).isEmpty()) {	×
180	blockEntity.getInventory().setItem(SLOT_FUEL, fuel.getItem().getCraftingRemainder(fuel));	×
181	}
182	blockEntity.currentlyBurningMax = getFuelTime(fuel);	×
183	blockEntity.currentlyBurning = 0;	×
184	blockEntity.setChanged();	×
185	}
186	blockEntity.updateBlockState();	×
187	}
188	}
189	}	×
190	}
191	}

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