classic-mods-revived/Jurassic-Revived
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

pipes (not done for fabric) and tank (maybe for fabric?)

Browse Source
This commit is contained in:
Eli Gibbs
2026-02-03 14:47:35 -05:00
parent 9deea24e7b
commit a30721d9b8
39 changed files with 2201 additions and 100 deletions
Download Patch File Download Diff File Expand all files Collapse all files
neoforge/src/main/java/net/cmr/jurassicrevived/event/NeoForgeEvents.java
+62 -18
View File
@@ -2,11 +2,18 @@ package net.cmr.jurassicrevived.event;
import net.cmr.jurassicrevived.Constants;
import net.cmr.jurassicrevived.block.entity.ModBlockEntities;
import net.cmr.jurassicrevived.block.entity.custom.FossilCleanerBlockEntity;
import net.cmr.jurassicrevived.block.entity.custom.GeneratorBlockEntity;
import net.cmr.jurassicrevived.config.JRConfigManager;
import net.cmr.jurassicrevived.block.entity.custom.PowerCellBlockEntity;
import net.cmr.jurassicrevived.block.entity.custom.TankBlockEntity;
import net.cmr.jurassicrevived.neoforge.capabilities.NeoForgeEnergyStorage;
import net.neoforged.bus.api.SubscribeEvent;
import net.neoforged.fml.common.EventBusSubscriber;
import net.neoforged.neoforge.capabilities.Capabilities;
import net.neoforged.neoforge.capabilities.RegisterCapabilitiesEvent;
import net.neoforged.neoforge.fluids.FluidStack;
import net.neoforged.neoforge.fluids.capability.IFluidHandler;
@EventBusSubscriber(modid = Constants.MOD_ID)
public class NeoForgeEvents
@@ -24,27 +31,64 @@ public class NeoForgeEvents
event.registerBlockEntity(Capabilities.ItemHandler.BLOCK, ModBlockEntities.EMBRYO_CALCIFICATION_MACHINE_BE.get(), (be, side) -> be.getItemHandler(side));
event.registerBlockEntity(Capabilities.ItemHandler.BLOCK, ModBlockEntities.CRATE_BE.get(), (be, side) -> be.getItemHandler(side));
event.registerBlockEntity(Capabilities.ItemHandler.BLOCK, ModBlockEntities.INCUBATOR_BE.get(), (be, side) -> be.getItemHandler(side));
*/
Energy
event.registerBlockEntity(Capabilities.EnergyStorage.BLOCK, ModBlockEntities.POWER_CELL_BE.get(), (be, side) -> be.getEnergyStorage(side));
event.registerBlockEntity(Capabilities.EnergyStorage.BLOCK, ModBlockEntities.GENERATOR_BE.get(), (be, side) -> be.getEnergyStorage(side));
// Energy
event.registerBlockEntity(Capabilities.EnergyStorage.BLOCK, ModBlockEntities.POWER_CELL_BE.get(),
(be, side) -> new NeoForgeEnergyStorage(((PowerCellBlockEntity) be).getEnergyStorage(side)));
Fluids
event.registerBlockEntity(Capabilities.FluidHandler.BLOCK, ModBlockEntities.TANK_BE.get(), (be, side) -> be.getTank(side));
event.registerBlockEntity(Capabilities.FluidHandler.BLOCK, ModBlockEntities.FOSSIL_CLEANER_BE.get(), (be, side) -> be.getTank(side));
event.registerBlockEntity(Capabilities.EnergyStorage.BLOCK, ModBlockEntities.GENERATOR_BE.get(),
(be, side) -> new NeoForgeEnergyStorage(((GeneratorBlockEntity) be).getEnergyStorage(side)));
Machine Logic (if config allows)
if (JRConfigManager.get().requirePower) {
event.registerBlockEntity(Capabilities.EnergyStorage.BLOCK, ModBlockEntities.DNA_EXTRACTOR_BE.get(), (be, side) -> be.getEnergyStorage(side));
event.registerBlockEntity(Capabilities.EnergyStorage.BLOCK, ModBlockEntities.DNA_ANALYZER_BE.get(), (be, side) -> be.getEnergyStorage(side));
event.registerBlockEntity(Capabilities.EnergyStorage.BLOCK, ModBlockEntities.FOSSIL_CLEANER_BE.get(), (be, side) -> be.getEnergyStorage(side));
event.registerBlockEntity(Capabilities.EnergyStorage.BLOCK, ModBlockEntities.FOSSIL_GRINDER_BE.get(), (be, side) -> be.getEnergyStorage(side));
event.registerBlockEntity(Capabilities.EnergyStorage.BLOCK, ModBlockEntities.DNA_HYBRIDIZER_BE.get(), (be, side) -> be.getEnergyStorage(side));
event.registerBlockEntity(Capabilities.EnergyStorage.BLOCK, ModBlockEntities.EMBRYONIC_MACHINE_BE.get(), (be, side) -> be.getEnergyStorage(side));
event.registerBlockEntity(Capabilities.EnergyStorage.BLOCK, ModBlockEntities.EMBRYO_CALCIFICATION_MACHINE_BE.get(), (be, side) -> be.getEnergyStorage(side));
event.registerBlockEntity(Capabilities.EnergyStorage.BLOCK, ModBlockEntities.INCUBATOR_BE.get(), (be, side) -> be.getEnergyStorage(side));
}
// Fluids
event.registerBlockEntity(Capabilities.FluidHandler.BLOCK, ModBlockEntities.TANK_BE.get(),
(be, side) -> new TankFluidAdapter(((TankBlockEntity) be).getTank(side)));
*/
//event.registerBlockEntity(Capabilities.FluidHandler.BLOCK, ModBlockEntities.FOSSIL_CLEANER_BE.get(),
// (be, side) -> new TankFluidAdapter(((FossilCleanerBlockEntity) be).getTank(side)));
}
private record TankFluidAdapter(TankBlockEntity.TankFluidHandler tank) implements IFluidHandler {
@Override
public int getTanks() {
return 1;
}
@Override
public FluidStack getFluidInTank(int tankIndex) {
if (tankIndex != 0) return FluidStack.EMPTY;
return new FluidStack(tank.getFluid().getFluid(), (int) tank.getFluid().getAmount());
}
@Override
public int getTankCapacity(int tankIndex) {
return tankIndex == 0 ? (int) tank.getCapacity() : 0;
}
@Override
public boolean isFluidValid(int tankIndex, FluidStack stack) {
return tankIndex == 0;
}
@Override
public int fill(FluidStack resource, FluidAction action) {
if (resource.isEmpty()) return 0;
long filled = tank.fill(dev.architectury.fluid.FluidStack.create(resource.getFluid(), resource.getAmount()), action.simulate());
return (int) filled;
}
@Override
public FluidStack drain(FluidStack resource, FluidAction action) {
if (resource.isEmpty()) return FluidStack.EMPTY;
var drained = tank.drain(resource.getAmount(), action.simulate());
return new FluidStack(drained.getFluid(), (int) drained.getAmount());
}
@Override
public FluidStack drain(int maxDrain, FluidAction action) {
var drained = tank.drain(maxDrain, action.simulate());
return new FluidStack(drained.getFluid(), (int) drained.getAmount());
}
}
}
neoforge/src/main/java/net/cmr/jurassicrevived/platform/NeoForgeItemFluidHelper.java
+84
View File
@@ -0,0 +1,84 @@
package net.cmr.jurassicrevived.platform;
import dev.architectury.fluid.FluidStack;
import net.cmr.jurassicrevived.platform.services.IItemFluidHelper;
import net.minecraft.world.item.ItemStack;
import net.minecraft.world.item.Items;
import net.minecraft.world.level.material.Fluids;
import net.neoforged.neoforge.fluids.FluidUtil;
import net.neoforged.neoforge.fluids.capability.IFluidHandlerItem;
import java.util.Optional;
public class NeoForgeItemFluidHelper implements IItemFluidHelper {
@Override
public Optional<FluidStack> getContainedFluid(ItemStack stack) {
Optional<FluidStack> handlerFluid = FluidUtil.getFluidHandler(stack.copy())
.map(handler -> {
if (handler.getTanks() <= 0) return FluidStack.empty();
var fs = handler.getFluidInTank(0);
if (fs.isEmpty()) return FluidStack.empty();
return FluidStack.create(fs.getFluid(), fs.getAmount());
});
if (handlerFluid.isPresent() && !handlerFluid.get().isEmpty()) return handlerFluid;
if (stack.is(Items.WATER_BUCKET)) {
return Optional.of(FluidStack.create(Fluids.WATER, 1000));
}
if (stack.is(Items.LAVA_BUCKET)) {
return Optional.of(FluidStack.create(Fluids.LAVA, 1000));
}
return Optional.of(FluidStack.empty());
}
@Override
public TransferResult drain(ItemStack stack, long amount, boolean simulate) {
Optional<TransferResult> handlerResult = FluidUtil.getFluidHandler(stack.copy())
.map(handler -> {
var drained = handler.drain((int) amount,
simulate ? IFluidHandlerItem.FluidAction.SIMULATE : IFluidHandlerItem.FluidAction.EXECUTE);
return new TransferResult(drained.getAmount(), handler.getContainer());
});
if (handlerResult.isPresent()) return handlerResult.get();
if (stack.is(Items.WATER_BUCKET) && amount >= 1000) {
return new TransferResult(1000, simulate ? stack : new ItemStack(Items.BUCKET));
}
if (stack.is(Items.LAVA_BUCKET) && amount >= 1000) {
return new TransferResult(1000, simulate ? stack : new ItemStack(Items.BUCKET));
}
return new TransferResult(0, stack);
}
@Override
public TransferResult fill(ItemStack stack, FluidStack fluid, long amount, boolean simulate) {
Optional<TransferResult> handlerResult = FluidUtil.getFluidHandler(stack.copy())
.map(handler -> {
var toFill = new net.neoforged.neoforge.fluids.FluidStack(fluid.getFluid(), (int) amount);
int filled = handler.fill(toFill,
simulate ? IFluidHandlerItem.FluidAction.SIMULATE : IFluidHandlerItem.FluidAction.EXECUTE);
return new TransferResult(filled, handler.getContainer());
});
if (handlerResult.isPresent()) return handlerResult.get();
if (stack.is(Items.BUCKET) && amount >= 1000) {
if (fluid.getFluid().isSame(Fluids.WATER)) {
return new TransferResult(1000, simulate ? stack : new ItemStack(Items.WATER_BUCKET));
}
if (fluid.getFluid().isSame(Fluids.LAVA)) {
return new TransferResult(1000, simulate ? stack : new ItemStack(Items.LAVA_BUCKET));
}
}
return new TransferResult(0, stack);
}
@Override
public boolean isFluidHandler(ItemStack stack) {
return FluidUtil.getFluidHandler(stack).isPresent() || stack.is(Items.BUCKET) || stack.is(Items.WATER_BUCKET) || stack.is(Items.LAVA_BUCKET);
}
}
neoforge/src/main/java/net/cmr/jurassicrevived/platform/NeoForgeTransferHelper.java
+161
View File
@@ -0,0 +1,161 @@
package net.cmr.jurassicrevived.platform;
import net.cmr.jurassicrevived.platform.services.ITransferHelper;
import net.cmr.jurassicrevived.platform.transfer.PlatformItemHandler;
import net.minecraft.core.BlockPos;
import net.minecraft.core.Direction;
import net.minecraft.world.item.ItemStack;
import net.minecraft.world.level.Level;
import net.minecraft.world.level.block.entity.BlockEntity;
import net.neoforged.neoforge.capabilities.Capabilities;
import dev.architectury.fluid.FluidStack;
import net.cmr.jurassicrevived.platform.transfer.InternalFluidHandlerAdapter;
import net.cmr.jurassicrevived.platform.transfer.InternalFluidProvider;
import net.cmr.jurassicrevived.platform.transfer.PlatformEnergyHandler;
import net.cmr.jurassicrevived.platform.transfer.PlatformFluidHandler;
import net.neoforged.neoforge.capabilities.Capabilities;
import net.neoforged.neoforge.energy.IEnergyStorage;
import net.neoforged.neoforge.fluids.capability.IFluidHandler;
import net.neoforged.neoforge.items.IItemHandler;
import net.neoforged.neoforge.items.ItemHandlerHelper;
import java.util.ArrayList;
import java.util.List;
import java.util.Optional;
public class NeoForgeTransferHelper implements ITransferHelper {
@Override
public Optional<PlatformItemHandler> getItemHandler(Level level, BlockPos pos, Direction side) {
IItemHandler handler = level.getCapability(Capabilities.ItemHandler.BLOCK, pos, side);
return Optional.ofNullable(handler).map(NeoForgeItemHandler::new);
}
@Override
public Optional<PlatformFluidHandler> getFluidHandler(Level level, BlockPos pos, Direction side) {
IFluidHandler handler = level.getCapability(Capabilities.FluidHandler.BLOCK, pos, side);
if (handler != null) return Optional.of(new NeoForgeFluidHandler(handler));
BlockEntity be = level.getBlockEntity(pos);
if (be instanceof InternalFluidProvider provider) {
return Optional.of(new InternalFluidHandlerAdapter(provider.getFluidHandler(side)));
}
return Optional.empty();
}
@Override
public Optional<PlatformEnergyHandler> getEnergyHandler(Level level, BlockPos pos, Direction side) {
IEnergyStorage storage = level.getCapability(Capabilities.EnergyStorage.BLOCK, pos, side);
return Optional.ofNullable(storage).map(NeoForgeEnergyHandler::new);
}
private static class NeoForgeFluidHandler implements PlatformFluidHandler {
private final IFluidHandler handler;
private NeoForgeFluidHandler(IFluidHandler handler) {
this.handler = handler;
}
@Override
public Iterable<FluidStack> getExtractableFluids() {
List<FluidStack> stacks = new ArrayList<>();
for (int i = 0; i < handler.getTanks(); i++) {
net.neoforged.neoforge.fluids.FluidStack fs = handler.getFluidInTank(i);
if (!fs.isEmpty()) {
stacks.add(FluidStack.create(fs.getFluid(), fs.getAmount()));
}
}
return stacks;
}
@Override
public long extract(FluidStack stack, long amount, boolean simulate) {
net.neoforged.neoforge.fluids.FluidStack req =
new net.neoforged.neoforge.fluids.FluidStack(stack.getFluid(), (int) amount);
net.neoforged.neoforge.fluids.FluidStack drained = handler.drain(
req,
simulate ? IFluidHandler.FluidAction.SIMULATE : IFluidHandler.FluidAction.EXECUTE
);
return drained.getAmount();
}
@Override
public long insert(FluidStack stack, long amount, boolean simulate) {
net.neoforged.neoforge.fluids.FluidStack toFill =
new net.neoforged.neoforge.fluids.FluidStack(stack.getFluid(), (int) amount);
return handler.fill(
toFill,
simulate ? IFluidHandler.FluidAction.SIMULATE : IFluidHandler.FluidAction.EXECUTE
);
}
}
private static class NeoForgeEnergyHandler implements PlatformEnergyHandler {
private final IEnergyStorage storage;
private NeoForgeEnergyHandler(IEnergyStorage storage) {
this.storage = storage;
}
@Override
public int extract(int amount, boolean simulate) {
return storage.extractEnergy(amount, simulate);
}
@Override
public int insert(int amount, boolean simulate) {
return storage.receiveEnergy(amount, simulate);
}
}
private static class NeoForgeItemHandler implements PlatformItemHandler {
private final IItemHandler handler;
private NeoForgeItemHandler(IItemHandler handler) {
this.handler = handler;
}
@Override
public Iterable<ItemStack> getExtractableStacks() {
List<ItemStack> stacks = new ArrayList<>();
for (int i = 0; i < handler.getSlots(); i++) {
ItemStack stack = handler.getStackInSlot(i);
if (!stack.isEmpty()) stacks.add(stack.copy());
}
return stacks;
}
@Override
public int extract(ItemStack stack, int amount, boolean simulate) {
int remaining = amount;
for (int i = 0; i < handler.getSlots() && remaining > 0; i++) {
ItemStack slot = handler.getStackInSlot(i);
if (!itemsMatch(slot, stack)) continue;
ItemStack extracted = handler.extractItem(i, remaining, simulate);
remaining -= extracted.getCount();
}
return amount - remaining;
}
private static boolean itemsMatch(ItemStack a, ItemStack b) {
//? if >1.20.1 {
return ItemStack.isSameItemSameComponents(a, b);
//?} else {
/*return ItemStack.isSameItemSameTags(a, b);*/
//?}
}
@Override
public int insert(ItemStack stack, int amount, boolean simulate) {
ItemStack toInsert = stack.copy();
toInsert.setCount(amount);
ItemStack remainder = toInsert;
for (int i = 0; i < handler.getSlots() && !remainder.isEmpty(); i++) {
remainder = handler.insertItem(i, remainder, simulate);
}
return amount - remainder.getCount();
}
}
}