24034486947

Committed 06 Apr 2026 01:51PM UTC coverage: 53.645% (-0.08%) from 53.721%

Build # 24034486947

Build Type

push

github

Committed by

rubensworks

Commit Message

Update to MC 26.1.1

Coverage Stats

3052 of 8931 branches covered (34.17%)

Branch coverage included in aggregate %.

18680 of 31580 relevant lines covered (59.15%)

3.07 hits per line

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

70.0

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

CyclopsMC / IntegratedDynamics / 24034486947

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