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

2026-02-03 14:47:35 -05:00
parent 9deea24e7b
commit a30721d9b8
39 changed files with 2201 additions and 100 deletions
@@ -7,6 +7,8 @@ import net.fabricmc.fabric.api.transfer.v1.fluid.FluidStorage;
 import net.fabricmc.fabric.api.transfer.v1.item.ItemStorage;
 import net.fabricmc.fabric.api.transfer.v1.item.ItemVariant;
 import net.fabricmc.fabric.api.transfer.v1.storage.Storage;
+import net.cmr.jurassicrevived.platform.FabricEnergyWrapper;
+import team.reborn.energy.api.EnergyStorage;

 public class JRMod implements ModInitializer
 {
@@ -22,15 +24,54 @@ public class JRMod implements ModInitializer
 		Constants.LOG.info("Hello Fabric world!");
 		CommonClass.init();

-		/*
-		 Items (Fabric Transfer API)
-		ItemStorage.SIDED.registerForBlockEntities((be, side) -> (Storage<ItemVariant>) ((CrateBlockEntity)be).itemHandler, ModBlockEntities.CRATE_BE.get());
+		EnergyStorage.SIDED.registerForBlockEntities((be, side) ->
+			new FabricEnergyWrapper(((PowerCellBlockEntity) be).getEnergyStorage(side)),
+			ModBlockEntities.POWER_CELL_BE.get()
+		);

-		 Energy (TeamReborn Energy API is standard for Fabric)
-		EnergyStorage.SIDED.registerForBlockEntities((be, side) -> ((PowerCellBlockEntity)be).getEnergyStorage(side), ModBlockEntities.POWER_CELL_BE.get());
+		EnergyStorage.SIDED.registerForBlockEntities((be, side) ->
+			new FabricEnergyWrapper(((GeneratorBlockEntity) be).getEnergyStorage(side)),
+			ModBlockEntities.GENERATOR_BE.get()
+		);

-		 Fluids (Fabric Transfer API)
-		FluidStorage.SIDED.registerForBlockEntities((be, side) -> ((TankBlockEntity)be).getTank(side), ModBlockEntities.TANK_BE.get());
-		 */
+		EnergyStorage.SIDED.registerForBlockEntities((be, side) ->
+			new FabricEnergyWrapper(((DNAExtractorBlockEntity) be).getEnergyStorage(side)),
+			ModBlockEntities.DNA_EXTRACTOR_BE.get()
+		);
+
+		EnergyStorage.SIDED.registerForBlockEntities((be, side) ->
+			new FabricEnergyWrapper(((DNAAnalyzerBlockEntity) be).getEnergyStorage(side)),
+			ModBlockEntities.DNA_ANALYZER_BE.get()
+		);
+
+		EnergyStorage.SIDED.registerForBlockEntities((be, side) ->
+			new FabricEnergyWrapper(((DNAHybridizerBlockEntity) be).getEnergyStorage(side)),
+			ModBlockEntities.DNA_HYBRIDIZER_BE.get()
+		);
+
+		EnergyStorage.SIDED.registerForBlockEntities((be, side) ->
+			new FabricEnergyWrapper(((FossilCleanerBlockEntity) be).getEnergyStorage(side)),
+			ModBlockEntities.FOSSIL_CLEANER_BE.get()
+		);
+
+		EnergyStorage.SIDED.registerForBlockEntities((be, side) ->
+			new FabricEnergyWrapper(((FossilGrinderBlockEntity) be).getEnergyStorage(side)),
+			ModBlockEntities.FOSSIL_GRINDER_BE.get()
+		);
+
+		EnergyStorage.SIDED.registerForBlockEntities((be, side) ->
+			new FabricEnergyWrapper(((EmbryonicMachineBlockEntity) be).getEnergyStorage(side)),
+			ModBlockEntities.EMBRYONIC_MACHINE_BE.get()
+		);
+
+		EnergyStorage.SIDED.registerForBlockEntities((be, side) ->
+			new FabricEnergyWrapper(((EmbryoCalcificationMachineBlockEntity) be).getEnergyStorage(side)),
+			ModBlockEntities.EMBRYO_CALCIFICATION_MACHINE_BE.get()
+		);
+
+		EnergyStorage.SIDED.registerForBlockEntities((be, side) ->
+			new FabricEnergyWrapper(((IncubatorBlockEntity) be).getEnergyStorage(side)),
+			ModBlockEntities.INCUBATOR_BE.get()
+		);
 	}
 }
@@ -0,0 +1,33 @@
+package net.cmr.jurassicrevived.platform;
+
+import net.cmr.jurassicrevived.block.entity.energy.ModEnergyStorage;
+import net.fabricmc.fabric.api.transfer.v1.transaction.TransactionContext;
+import team.reborn.energy.api.EnergyStorage;
+
+public class FabricEnergyWrapper implements EnergyStorage {
+	private final ModEnergyStorage storage;
+
+	public FabricEnergyWrapper(ModEnergyStorage storage) {
+		this.storage = storage;
+	}
+
+	@Override
+	public long insert(long maxAmount, TransactionContext transaction) {
+		return storage.receiveEnergy((int) maxAmount, true);
+	}
+
+	@Override
+	public long extract(long maxAmount, TransactionContext transaction) {
+		return storage.extractEnergy((int) maxAmount, true);
+	}
+
+	@Override
+	public long getAmount() {
+		return storage.getEnergyStored();
+	}
+
+	@Override
+	public long getCapacity() {
+		return storage.getMaxEnergyStored();
+	}
+}
@@ -0,0 +1,103 @@
+package net.cmr.jurassicrevived.platform;
+
+import dev.architectury.fluid.FluidStack;
+import net.cmr.jurassicrevived.platform.services.IItemFluidHelper;
+import net.fabricmc.fabric.api.transfer.v1.context.ContainerItemContext;
+import net.fabricmc.fabric.api.transfer.v1.fluid.FluidStorage;
+import net.fabricmc.fabric.api.transfer.v1.fluid.FluidVariant;
+import net.fabricmc.fabric.api.transfer.v1.item.ItemVariant;
+import net.fabricmc.fabric.api.transfer.v1.storage.Storage;
+import net.fabricmc.fabric.api.transfer.v1.storage.StorageView;
+import net.fabricmc.fabric.api.transfer.v1.transaction.Transaction;
+import net.minecraft.world.item.ItemStack;
+import net.minecraft.world.item.Items;
+import net.minecraft.world.level.material.Fluids;
+
+import java.util.Optional;
+
+public class FabricItemFluidHelper implements IItemFluidHelper {
+
+	@Override
+	public Optional<FluidStack> getContainedFluid(ItemStack stack) {
+		ContainerItemContext ctx = ContainerItemContext.withConstant(stack.copy());
+		Storage<FluidVariant> storage = ctx.find(FluidStorage.ITEM);
+		if (storage == null) {
+			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.empty();
+		}
+
+		for (StorageView<FluidVariant> view : storage) {
+			if (!view.isResourceBlank() && view.getAmount() > 0) {
+				return Optional.of(FluidStack.create(view.getResource().getFluid(), view.getAmount()));
+			}
+		}
+		return Optional.of(FluidStack.empty());
+	}
+
+	@Override
+	public TransferResult drain(ItemStack stack, long amount, boolean simulate) {
+		ContainerItemContext ctx = ContainerItemContext.withConstant(stack.copy());
+		Storage<FluidVariant> storage = ctx.find(FluidStorage.ITEM);
+		if (storage == null) {
+			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);
+		}
+
+		try (Transaction tx = Transaction.openOuter()) {
+			long extracted = 0;
+			for (StorageView<FluidVariant> view : storage) {
+				if (!view.isResourceBlank()) {
+					extracted = storage.extract(view.getResource(), amount, tx);
+					if (extracted > 0) break;
+				}
+			}
+
+			if (extracted > 0) {
+				if (!simulate) tx.commit();
+				ItemStack resultStack = ctx.getItemVariant().toStack((int) ctx.getAmount());
+				return new TransferResult(extracted, resultStack);
+			}
+		}
+		return new TransferResult(0, stack);
+	}
+
+	@Override
+	public TransferResult fill(ItemStack stack, FluidStack fluid, long amount, boolean simulate) {
+		ContainerItemContext ctx = ContainerItemContext.withConstant(stack.copy());
+		Storage<FluidVariant> storage = ctx.find(FluidStorage.ITEM);
+		if (storage == null) {
+			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);
+		}
+
+		try (Transaction tx = Transaction.openOuter()) {
+			long inserted = storage.insert(FluidVariant.of(fluid.getFluid()), amount, tx);
+			if (inserted > 0) {
+				if (!simulate) tx.commit();
+				ItemStack resultStack = ctx.getItemVariant().toStack((int) ctx.getAmount());
+				return new TransferResult(inserted, resultStack);
+			}
+		}
+		return new TransferResult(0, stack);
+	}
+
+	@Override
+	public boolean isFluidHandler(ItemStack stack) {
+		ContainerItemContext ctx = ContainerItemContext.withConstant(stack);
+		Storage<FluidVariant> storage = ctx.find(FluidStorage.ITEM);
+		return storage != null || stack.is(Items.BUCKET) || stack.is(Items.WATER_BUCKET) || stack.is(Items.LAVA_BUCKET);
+	}
+}
@@ -0,0 +1,146 @@
+package net.cmr.jurassicrevived.platform;
+
+import net.cmr.jurassicrevived.platform.services.ITransferHelper;
+import net.cmr.jurassicrevived.platform.transfer.PlatformItemHandler;
+import net.fabricmc.fabric.api.transfer.v1.item.ItemStorage;
+import net.fabricmc.fabric.api.transfer.v1.item.ItemVariant;
+import net.fabricmc.fabric.api.transfer.v1.storage.Storage;
+import net.fabricmc.fabric.api.transfer.v1.storage.StorageView;
+import net.fabricmc.fabric.api.transfer.v1.transaction.Transaction;
+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 dev.architectury.fluid.FluidStack;
+import team.reborn.energy.api.EnergyStorage;
+import net.cmr.jurassicrevived.platform.transfer.PlatformEnergyHandler;
+import net.cmr.jurassicrevived.platform.transfer.PlatformFluidHandler;
+import net.fabricmc.fabric.api.transfer.v1.fluid.FluidStorage;
+import net.fabricmc.fabric.api.transfer.v1.fluid.FluidVariant;
+import net.fabricmc.fabric.api.transfer.v1.storage.StorageView;
+import net.fabricmc.fabric.api.transfer.v1.transaction.Transaction;
+//import net.fabricmc.fabric.api.transfer.v1.energy.EnergyStorage;
+//import team.reborn.energy.api.EnergyStorage;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Optional;
+
+public class FabricTransferHelper implements ITransferHelper {
+
+	@Override
+	public Optional<PlatformItemHandler> getItemHandler(Level level, BlockPos pos, Direction side) {
+		Storage<ItemVariant> storage = ItemStorage.SIDED.find(level, pos, side);
+		if (storage == null) return Optional.empty();
+		return Optional.of(new FabricItemHandler(storage));
+	}
+
+	@Override
+	public Optional<PlatformFluidHandler> getFluidHandler(Level level, BlockPos pos, Direction side) {
+		var storage = FluidStorage.SIDED.find(level, pos, side);
+		if (storage == null) return Optional.empty();
+		return Optional.of(new FabricFluidHandler(storage));
+	}
+
+	@Override
+	public Optional<PlatformEnergyHandler> getEnergyHandler(Level level, BlockPos pos, Direction side) {
+		EnergyStorage storage = EnergyStorage.SIDED.find(level, pos, side);
+		return Optional.empty();
+	}
+
+	private static class FabricFluidHandler implements PlatformFluidHandler {
+		private final net.fabricmc.fabric.api.transfer.v1.storage.Storage<FluidVariant> storage;
+
+		private FabricFluidHandler(net.fabricmc.fabric.api.transfer.v1.storage.Storage<FluidVariant> storage) {
+			this.storage = storage;
+		}
+
+		@Override
+		public Iterable<FluidStack> getExtractableFluids() {
+			List<FluidStack> stacks = new ArrayList<>();
+			for (StorageView<FluidVariant> view : storage) {
+				if (view.isResourceBlank()) continue;
+				FluidVariant v = view.getResource();
+				long amt = view.getAmount();
+				if (amt > 0) {
+					FluidStack stack = FluidStack.create(v.getFluid(), amt);
+					stacks.add(stack);
+				}
+			}
+			return stacks;
+		}
+
+		@Override
+		public long extract(FluidStack stack, long amount, boolean simulate) {
+			try (Transaction tx = Transaction.openOuter()) {
+				long extracted = storage.extract(FluidVariant.of(stack.getFluid()), amount, tx);
+				if (!simulate) tx.commit();
+				return extracted;
+			}
+		}
+
+		@Override
+		public long insert(FluidStack stack, long amount, boolean simulate) {
+			try (Transaction tx = Transaction.openOuter()) {
+				long inserted = storage.insert(FluidVariant.of(stack.getFluid()), amount, tx);
+				if (!simulate) tx.commit();
+				return inserted;
+			}
+		}
+	}
+
+	private static class FabricEnergyHandler implements PlatformEnergyHandler {
+		private FabricEnergyHandler() {
+		}
+
+		@Override
+		public int extract(int amount, boolean simulate) {
+			return 0;
+		}
+
+		@Override
+		public int insert(int amount, boolean simulate) {
+			return 0;
+		}
+	}
+
+	private static class FabricItemHandler implements PlatformItemHandler {
+		private final Storage<ItemVariant> storage;
+
+		private FabricItemHandler(Storage<ItemVariant> storage) {
+			this.storage = storage;
+		}
+
+		@Override
+		public Iterable<ItemStack> getExtractableStacks() {
+			List<ItemStack> stacks = new ArrayList<>();
+			for (StorageView<ItemVariant> view : storage) {
+				if (view.isResourceBlank()) continue;
+				ItemVariant v = view.getResource();
+				long amt = view.getAmount();
+				if (amt > 0) stacks.add(v.toStack((int) Math.min(amt, Integer.MAX_VALUE)));
+			}
+			return stacks;
+		}
+
+		@Override
+		public int extract(ItemStack stack, int amount, boolean simulate) {
+			try (Transaction tx = Transaction.openOuter()) {
+				long extracted = storage.extract(ItemVariant.of(stack), amount, tx);
+				if (!simulate) tx.commit();
+				return (int) extracted;
+			}
+		}
+
+		@Override
+		public int insert(ItemStack stack, int amount, boolean simulate) {
+			try (Transaction tx = Transaction.openOuter()) {
+				long inserted = storage.insert(ItemVariant.of(stack), amount, tx);
+				if (!simulate) tx.commit();
+				return (int) inserted;
+			}
+		}
+	}
+}