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

Moved save logic inside the 1.20 branch, as they don't compile without errors on 1.21

Browse Source 
Change hybridizer logic to no longer require a catalyst
fix brachiosaurus_dna.png
Fix flame texture on generator for 1.21
Adds power handling for machines in NF 1.21
Adds power handling to fabric
Actually fix screen registration for Fabric 1.20
This commit is contained in:
Eli Gibbs
2026-05-20 22:56:50 -04:00
parent 40292ae052
commit 05325f6008
35 changed files with 631 additions and 230 deletions
Download Patch File Download Diff File Expand all files Collapse all files
fabricmc/src/main/java/net/cmr/jurassicrevived/JRModClient.java
+4
View File
@@ -12,6 +12,10 @@ public class JRModClient implements ClientModInitializer {
public void onInitializeClient() {
CommonClientClass.init();
//? if <=1.20.1 {
CommonClientClass.registerScreens();
//?}
BlockRenderLayerMap.INSTANCE.putBlock(ModBlocks.TANK.get(), RenderType.translucent());
BlockRenderLayerMap.INSTANCE.putBlock(ModBlocks.INCUBATOR.get(), RenderType.translucent());
BlockRenderLayerMap.INSTANCE.putBlock(ModBlocks.DNA_EXTRACTOR.get(), RenderType.translucent());
fabricmc/src/main/java/net/cmr/jurassicrevived/datagen/FabricRecipeProvider.java
+13 -15
View File
@@ -188,26 +188,24 @@ public class FabricRecipeProvider extends net.fabricmc.fabric.api.datagen.v1.pro
//?}
}
@Override
public void dnaHybridizing(ItemLike result, int count, ItemLike catalyst, ItemLike... ingredients) {
//? if >1.20.1 {
/*DNAHybridizingRecipeBuilder builder = new DNAHybridizingRecipeBuilder(result, count)
.setCatalyst(catalyst);
@Override
public void dnaHybridizing(ItemLike result, int count, ItemLike... ingredients) {
//? if >1.20.1 {
/*DNAHybridizingRecipeBuilder builder = new DNAHybridizingRecipeBuilder(result, count);
for (ItemLike ingredient : ingredients) {
builder.addIngredient(ingredient);
}
builder.unlockedBy("has_dna", has(ingredients[0]))
.save(output);
*///?} else {
DNAHybridizingRecipeBuilder builder = new DNAHybridizingRecipeBuilder(result, count);
for (ItemLike ingredient : ingredients) {
builder.addIngredient(ingredient);
}
builder.unlockedBy("has_catalyst", has(catalyst))
.save(output);
*///?} else {
DNAHybridizingRecipeBuilder builder = new DNAHybridizingRecipeBuilder(result, count)
.setCatalyst(catalyst);
for (ItemLike ingredient : ingredients) {
builder.addIngredient(ingredient);
}
builder.unlockedBy("has_catalyst", has(catalyst))
builder.unlockedBy("has_dna", has(ingredients[0]))
.save(output);
//?}
}
}
@Override
public void embryonicMachine(ItemLike syringe, ItemLike dna, ItemLike catalyst, ItemLike result, int count) {
fabricmc/src/main/java/net/cmr/jurassicrevived/platform/FabricItemFluidHelper.java
+59 -30
View File
@@ -3,6 +3,7 @@ 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.FluidConstants;
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;
@@ -16,20 +17,32 @@ import net.minecraft.world.level.material.Fluids;
import java.util.Optional;
public class FabricItemFluidHelper implements IItemFluidHelper {
private static final long MB_PER_BUCKET = 1000L;
private static long dropletsToMb(long droplets) {
if (droplets <= 0) return 0;
return Math.max(1, droplets * MB_PER_BUCKET / FluidConstants.BUCKET);
}
private static long mbToDroplets(long mb) {
if (mb <= 0) return 0;
return mb * FluidConstants.BUCKET / MB_PER_BUCKET;
}
@Override
public Optional<FluidStack> getContainedFluid(ItemStack stack) {
ContainerItemContext ctx = ContainerItemContext.withConstant(stack.copy());
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));
ContainerItemContext ctx = ContainerItemContext.withConstant(ItemVariant.of(stack), stack.getCount());
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.create(view.getResource().getFluid(), dropletsToMb(view.getAmount())));
}
}
return Optional.of(FluidStack.empty());
@@ -37,31 +50,37 @@ public class FabricItemFluidHelper implements IItemFluidHelper {
@Override
public TransferResult drain(ItemStack stack, long amount, boolean simulate) {
ContainerItemContext ctx = ContainerItemContext.withConstant(stack.copy());
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));
}
ContainerItemContext ctx = ContainerItemContext.withConstant(ItemVariant.of(stack), stack.getCount());
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;
long requestedDroplets = mbToDroplets(amount);
long extractedDroplets = 0;
for (StorageView<FluidVariant> view : storage) {
if (!view.isResourceBlank()) {
extracted = storage.extract(view.getResource(), amount, tx);
if (extracted > 0) break;
extractedDroplets = storage.extract(view.getResource(), requestedDroplets, tx);
if (extractedDroplets > 0) break;
}
}
if (extracted > 0) {
if (extractedDroplets > 0) {
long extractedMb = dropletsToMb(extractedDroplets);
if (!simulate) tx.commit();
ItemStack resultStack = ctx.getItemVariant().toStack((int) ctx.getAmount());
return new TransferResult(extracted, resultStack);
return new TransferResult(extractedMb, resultStack);
}
}
return new TransferResult(0, stack);
@@ -69,26 +88,32 @@ public class FabricItemFluidHelper implements IItemFluidHelper {
@Override
public TransferResult fill(ItemStack stack, FluidStack fluid, long amount, boolean simulate) {
ContainerItemContext ctx = ContainerItemContext.withConstant(stack.copy());
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));
}
}
ContainerItemContext ctx = ContainerItemContext.withConstant(ItemVariant.of(stack), stack.getCount());
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) {
long requestedDroplets = mbToDroplets(amount);
long insertedDroplets = storage.insert(FluidVariant.of(fluid.getFluid()), requestedDroplets, tx);
if (insertedDroplets > 0) {
long insertedMb = dropletsToMb(insertedDroplets);
if (!simulate) tx.commit();
ItemStack resultStack = ctx.getItemVariant().toStack((int) ctx.getAmount());
return new TransferResult(inserted, resultStack);
return new TransferResult(insertedMb, resultStack);
}
}
return new TransferResult(0, stack);
@@ -96,8 +121,12 @@ public class FabricItemFluidHelper implements IItemFluidHelper {
@Override
public boolean isFluidHandler(ItemStack stack) {
ContainerItemContext ctx = ContainerItemContext.withConstant(stack);
if (stack.is(Items.BUCKET) || stack.is(Items.WATER_BUCKET) || stack.is(Items.LAVA_BUCKET)) {
return true;
}
ContainerItemContext ctx = ContainerItemContext.withConstant(ItemVariant.of(stack), stack.getCount());
Storage<FluidVariant> storage = ctx.find(FluidStorage.ITEM);
return storage != null || stack.is(Items.BUCKET) || stack.is(Items.WATER_BUCKET) || stack.is(Items.LAVA_BUCKET);
return storage != null;
}
}
fabricmc/src/main/java/net/cmr/jurassicrevived/platform/FabricTransferHelper.java
+105 -25
View File
@@ -12,18 +12,16 @@ 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 net.cmr.jurassicrevived.platform.transfer.InternalFluidHandler;
import net.cmr.jurassicrevived.platform.transfer.InternalFluidProvider;
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 net.fabricmc.fabric.api.transfer.v1.fluid.FluidConstants;
import java.util.ArrayList;
import java.util.Iterator;
@@ -31,6 +29,17 @@ import java.util.List;
import java.util.Optional;
public class FabricTransferHelper implements ITransferHelper {
private static final long MB_PER_BUCKET = 1000L;
private static long dropletsToMb(long droplets) {
if (droplets <= 0) return 0;
return Math.max(1, droplets * MB_PER_BUCKET / FluidConstants.BUCKET);
}
private static long mbToDroplets(long mb) {
if (mb <= 0) return 0;
return mb * FluidConstants.BUCKET / MB_PER_BUCKET;
}
@Override
public Optional<PlatformItemHandler> getItemHandler(Level level, BlockPos pos, Direction side) {
@@ -41,6 +50,13 @@ public class FabricTransferHelper implements ITransferHelper {
@Override
public Optional<PlatformFluidHandler> getFluidHandler(Level level, BlockPos pos, Direction side) {
if (level.getBlockEntity(pos) instanceof InternalFluidProvider provider) {
InternalFluidHandler handler = provider.getFluidHandler(side);
if (handler != null) {
return Optional.of(new DirectInternalFluidHandler(handler));
}
}
var storage = FluidStorage.SIDED.find(level, pos, side);
if (storage == null) return Optional.empty();
return Optional.of(new FabricFluidHandler(storage));
@@ -49,7 +65,8 @@ public class FabricTransferHelper implements ITransferHelper {
@Override
public Optional<PlatformEnergyHandler> getEnergyHandler(Level level, BlockPos pos, Direction side) {
EnergyStorage storage = EnergyStorage.SIDED.find(level, pos, side);
return Optional.empty();
if (storage == null) return Optional.empty();
return Optional.of(new FabricEnergyHandler(storage));
}
public static class InternalFluidStorage implements Storage<FluidVariant> {
@@ -65,18 +82,19 @@ public class FabricTransferHelper implements ITransferHelper {
return 0;
}
FluidStack stack = FluidStack.create(resource.getFluid(), maxAmount);
long inserted = handler.fill(stack, true);
long maxAmountMb = dropletsToMb(maxAmount);
FluidStack stack = FluidStack.create(resource.getFluid(), maxAmountMb);
long insertedMb = handler.fill(stack, true);
if (inserted > 0) {
if (insertedMb > 0) {
transaction.addCloseCallback((tx, result) -> {
if (result.wasCommitted()) {
handler.fill(FluidStack.create(resource.getFluid(), inserted), false);
handler.fill(FluidStack.create(resource.getFluid(), insertedMb), false);
}
});
}
return inserted;
return Math.min(maxAmount, mbToDroplets(insertedMb));
}
@Override
@@ -90,17 +108,18 @@ public class FabricTransferHelper implements ITransferHelper {
return 0;
}
long extracted = Math.min(maxAmount, stored.getAmount());
long maxAmountMb = dropletsToMb(maxAmount);
long extractedMb = Math.min(maxAmountMb, stored.getAmount());
if (extracted > 0) {
if (extractedMb > 0) {
transaction.addCloseCallback((tx, result) -> {
if (result.wasCommitted()) {
handler.drain(extracted, false);
handler.drain(extractedMb, false);
}
});
}
return extracted;
return Math.min(maxAmount, mbToDroplets(extractedMb));
}
@Override
@@ -114,12 +133,12 @@ public class FabricTransferHelper implements ITransferHelper {
@Override
public long getAmount() {
return stored.getAmount();
return mbToDroplets(stored.getAmount());
}
@Override
public long getCapacity() {
return handler.getCapacity();
return mbToDroplets(handler.getCapacity());
}
@Override
@@ -135,6 +154,44 @@ public class FabricTransferHelper implements ITransferHelper {
}
}
private static class DirectInternalFluidHandler implements PlatformFluidHandler {
private final InternalFluidHandler handler;
private DirectInternalFluidHandler(InternalFluidHandler handler) {
this.handler = handler;
}
@Override
public Iterable<FluidStack> getExtractableFluids() {
FluidStack stored = handler.getFluid();
if (stored.isEmpty()) {
return List.of();
}
return List.of(stored.copy());
}
@Override
public long extract(FluidStack stack, long amount, boolean simulate) {
FluidStack stored = handler.getFluid();
if (stored.isEmpty() || stored.getFluid() != stack.getFluid()) {
return 0;
}
return handler.drain(amount, simulate).getAmount();
}
@Override
public long insert(FluidStack stack, long amount, boolean simulate) {
if (stack.isEmpty() || amount <= 0) {
return 0;
}
FluidStack toInsert = stack.copy();
toInsert.setAmount(amount);
return handler.fill(toInsert, simulate);
}
}
private static class FabricFluidHandler implements PlatformFluidHandler {
private final Storage<FluidVariant> storage;
@@ -148,7 +205,7 @@ public class FabricTransferHelper implements ITransferHelper {
for (StorageView<FluidVariant> view : storage) {
if (view.isResourceBlank()) continue;
FluidVariant v = view.getResource();
long amt = view.getAmount();
long amt = dropletsToMb(view.getAmount());
if (amt > 0) {
FluidStack stack = FluidStack.create(v.getFluid(), amt);
stacks.add(stack);
@@ -160,34 +217,57 @@ public class FabricTransferHelper implements ITransferHelper {
@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);
long extractedDroplets = storage.extract(FluidVariant.of(stack.getFluid()), mbToDroplets(amount), tx);
if (!simulate) tx.commit();
return extracted;
return dropletsToMb(extractedDroplets);
}
}
@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);
long insertedDroplets = storage.insert(FluidVariant.of(stack.getFluid()), mbToDroplets(amount), tx);
if (!simulate) tx.commit();
return inserted;
return dropletsToMb(insertedDroplets);
}
}
}
private static class FabricEnergyHandler implements PlatformEnergyHandler {
private FabricEnergyHandler() {
private final EnergyStorage storage;
private FabricEnergyHandler(EnergyStorage storage) {
this.storage = storage;
}
@Override
public int extract(int amount, boolean simulate) {
return 0;
if (amount <= 0) {
return 0;
}
try (Transaction tx = Transaction.openOuter()) {
long extracted = storage.extract(amount, tx);
if (!simulate) {
tx.commit();
}
return (int) Math.min(Integer.MAX_VALUE, extracted);
}
}
@Override
public int insert(int amount, boolean simulate) {
return 0;
if (amount <= 0) {
return 0;
}
try (Transaction tx = Transaction.openOuter()) {
long inserted = storage.insert(amount, tx);
if (!simulate) {
tx.commit();
}
return (int) Math.min(Integer.MAX_VALUE, inserted);
}
}
}