Portable Fluid Tank

Patbox · Aug 15, 2024 · 470573c · 470573c
1 parent f93451b
commit 470573c
Show file tree

Hide file tree

Showing 32 changed files with 525 additions and 91 deletions.
diff --git a/src/main/java/eu/pb4/polyfactory/ModInit.java b/src/main/java/eu/pb4/polyfactory/ModInit.java
@@ -60,13 +60,13 @@ public void onInitialize() {
 			LOGGER.warn("=====================================================");
 		}
 		FactoryRegistries.setup();
-		FactoryFluids.register();
 		FactoryBlocks.register();
 		FactoryPoi.register();
 		FactoryBlockEntities.register();
 		FactoryEnchantmentEffectComponents.register();
 		FactoryDataComponents.register();
 		FactoryItems.register();
+		FactoryFluids.register();
 		FactoryEntities.register();
 		FactoryNodes.register();
 		FactoryRecipeTypes.register();

diff --git a/src/main/java/eu/pb4/polyfactory/block/FactoryBlockEntities.java b/src/main/java/eu/pb4/polyfactory/block/FactoryBlockEntities.java
@@ -136,6 +136,8 @@ public class FactoryBlockEntities {
     public static final BlockEntityType<MSpoutBlockEntity> MECHANICAL_SPOUT = register("mechanical_spout", BlockEntityType.Builder.create(MSpoutBlockEntity::new, FactoryBlocks.MECHANICAL_SPOUT));
     public static final BlockEntityType<CreativeDrainBlockEntity> CREATIVE_DRAIN = register("creative_drain", BlockEntityType.Builder.create(CreativeDrainBlockEntity::new, FactoryBlocks.CREATIVE_DRAIN));
     public static final BlockEntityType<FluidTankBlockEntity> FLUID_TANK = register("fluid_tank", BlockEntityType.Builder.create(FluidTankBlockEntity::new, FactoryBlocks.FLUID_TANK));
+    public static final BlockEntityType<PortableFluidTankBlockEntity> PORTABLE_FLUID_TANK = register("portable_fluid_tank",
+            BlockEntityType.Builder.create(PortableFluidTankBlockEntity::new, FactoryBlocks.PORTABLE_FLUID_TANK));
 
     public static void register() {
         var x = (BlockEntityTypeAccessor) BlockEntityType.HOPPER;

diff --git a/src/main/java/eu/pb4/polyfactory/block/FactoryBlocks.java b/src/main/java/eu/pb4/polyfactory/block/FactoryBlocks.java
@@ -35,6 +35,7 @@
 import net.minecraft.registry.Registries;
 import net.minecraft.registry.Registry;
 import net.minecraft.server.MinecraftServer;
+import net.minecraft.sound.BlockSoundGroup;
 import net.minecraft.state.property.Properties;
 import net.minecraft.util.Identifier;
 import net.minecraft.util.math.BlockPos;
@@ -119,6 +120,7 @@ public class FactoryBlocks {
     public static final MSpoutBlock MECHANICAL_SPOUT = register("mechanical_spout", new MSpoutBlock(AbstractBlock.Settings.copy(SPLITTER).nonOpaque()));
     public static final CreativeDrainBlock CREATIVE_DRAIN = register("creative_drain", new CreativeDrainBlock(AbstractBlock.Settings.copy(DRAIN).dropsNothing().strength(-1)));
     public static final FluidTankBlock FLUID_TANK = register("fluid_tank", new FluidTankBlock(AbstractBlock.Settings.copy(Blocks.COPPER_BLOCK).nonOpaque()));
+    public static final PortableFluidTankBlock PORTABLE_FLUID_TANK = register("portable_fluid_tank", new PortableFluidTankBlock(AbstractBlock.Settings.create().mapColor(MapColor.ORANGE).strength(2.0F).nonOpaque().sounds(BlockSoundGroup.COPPER)));
 
     public static void register() {
         var s = System.currentTimeMillis();

diff --git a/src/main/java/eu/pb4/polyfactory/block/fluids/DrainBlockEntity.java b/src/main/java/eu/pb4/polyfactory/block/fluids/DrainBlockEntity.java
@@ -88,6 +88,11 @@ public FluidContainer getFluidContainer(Direction direction) {
         return this.container;
     }
 
+    @Override
+    public @Nullable FluidContainer getMainFluidContainer() {
+        return this.container;
+    }
+
     private void onFluidChanged() {
         this.markDirty();
         this.updateModel();

diff --git a/src/main/java/eu/pb4/polyfactory/block/fluids/FluidContainerOwner.java b/src/main/java/eu/pb4/polyfactory/block/fluids/FluidContainerOwner.java
@@ -1,10 +1,26 @@
 package eu.pb4.polyfactory.block.fluids;
 
+import eu.pb4.polyfactory.block.other.FilledStateProvider;
 import eu.pb4.polyfactory.fluid.FluidContainer;
+import eu.pb4.polyfactory.util.FactoryUtil;
+import net.minecraft.text.Text;
+import net.minecraft.util.Formatting;
 import net.minecraft.util.math.Direction;
 import org.jetbrains.annotations.Nullable;
 
-public interface FluidContainerOwner {
+public interface FluidContainerOwner extends FilledStateProvider {
     @Nullable
     FluidContainer getFluidContainer(Direction direction);
+
+    @Nullable
+    FluidContainer getMainFluidContainer();
+
+
+    @Override
+    default Text getFilledStateText() {
+        var main = getMainFluidContainer();
+        return main != null ?
+                Text.translatable("text.polyfactory.x_out_of_y", FactoryUtil.fluidText(main.stored()), FactoryUtil.fluidText(main.capacity()))
+                : null;
+    }
 }
diff --git a/src/main/java/eu/pb4/polyfactory/block/fluids/FluidTankBlockEntity.java b/src/main/java/eu/pb4/polyfactory/block/fluids/FluidTankBlockEntity.java
@@ -104,6 +104,11 @@ public FluidContainer getFluidContainer(Direction direction) {
         return this.container;
     }
 
+    @Override
+    public @Nullable FluidContainer getMainFluidContainer() {
+        return this.container;
+    }
+
     private void onFluidChanged() {
         this.markDirty();
     }

diff --git a/src/main/java/eu/pb4/polyfactory/block/fluids/MDrainBlockEntity.java b/src/main/java/eu/pb4/polyfactory/block/fluids/MDrainBlockEntity.java
@@ -382,6 +382,11 @@ public FluidContainer getFluidContainer(Direction direction) {
         return this.fluidContainer;
     }
 
+    @Override
+    public @Nullable FluidContainer getMainFluidContainer() {
+        return this.fluidContainer;
+    }
+
 
     public ItemStack catalyst() {
         return this.getStack(CATALYST_FIRST);

diff --git a/src/main/java/eu/pb4/polyfactory/block/fluids/PipeLikeBlockEntity.java b/src/main/java/eu/pb4/polyfactory/block/fluids/PipeLikeBlockEntity.java
@@ -21,6 +21,7 @@
 import net.minecraft.util.ItemScatterer;
 import net.minecraft.util.math.BlockPos;
 import net.minecraft.util.math.Direction;
+import org.jetbrains.annotations.Nullable;
 
 public abstract class PipeLikeBlockEntity extends BlockEntity implements FluidInput.ContainerBased, DebugTextProvider {
     protected final FluidContainer container = this.createContainer();
@@ -40,6 +41,11 @@ public FluidContainer getFluidContainer() {
         return this.container;
     }
 
+    @Override
+    public @Nullable FluidContainer getMainFluidContainer() {
+        return this.container;
+    }
+
     @Override
     protected void writeNbt(NbtCompound nbt, RegistryWrapper.WrapperLookup registryLookup) {
         super.writeNbt(nbt, registryLookup);

diff --git a/src/main/java/eu/pb4/polyfactory/block/fluids/PortableFluidTankBlock.java b/src/main/java/eu/pb4/polyfactory/block/fluids/PortableFluidTankBlock.java
@@ -0,0 +1,135 @@
+package eu.pb4.polyfactory.block.fluids;
+
+import eu.pb4.factorytools.api.block.BarrierBasedWaterloggable;
+import eu.pb4.factorytools.api.block.FactoryBlock;
+import eu.pb4.factorytools.api.virtualentity.BlockModel;
+import eu.pb4.factorytools.api.virtualentity.ItemDisplayElementUtil;
+import eu.pb4.polyfactory.block.property.ConnectablePart;
+import eu.pb4.polyfactory.block.property.FactoryProperties;
+import eu.pb4.polyfactory.fluid.FluidContainer;
+import eu.pb4.polyfactory.fluid.FluidInstance;
+import eu.pb4.polyfactory.models.FactoryModels;
+import eu.pb4.polyfactory.models.fluid.MultiFluidViewModel;
+import eu.pb4.polymer.virtualentity.api.ElementHolder;
+import eu.pb4.polymer.virtualentity.api.attachment.BlockAwareAttachment;
+import eu.pb4.polymer.virtualentity.api.attachment.HolderAttachment;
+import eu.pb4.polymer.virtualentity.api.elements.ItemDisplayElement;
+import net.minecraft.block.Block;
+import net.minecraft.block.BlockEntityProvider;
+import net.minecraft.block.BlockState;
+import net.minecraft.block.Blocks;
+import net.minecraft.block.entity.BlockEntity;
+import net.minecraft.block.entity.BlockEntityTicker;
+import net.minecraft.block.entity.BlockEntityType;
+import net.minecraft.item.ItemPlacementContext;
+import net.minecraft.server.network.ServerPlayerEntity;
+import net.minecraft.server.world.ServerWorld;
+import net.minecraft.state.StateManager;
+import net.minecraft.state.property.DirectionProperty;
+import net.minecraft.state.property.EnumProperty;
+import net.minecraft.state.property.Properties;
+import net.minecraft.util.math.BlockPos;
+import net.minecraft.util.math.Direction;
+import net.minecraft.world.World;
+import net.minecraft.world.WorldAccess;
+import org.jetbrains.annotations.Nullable;
+import org.joml.Vector3f;
+
+public class PortableFluidTankBlock extends Block implements FactoryBlock, PipeConnectable, BlockEntityProvider, BarrierBasedWaterloggable {
+    public static final DirectionProperty FACING = Properties.FACING;
+    public PortableFluidTankBlock(Settings settings) {
+        super(settings);
+        this.setDefaultState(this.getDefaultState().with(WATERLOGGED, false));
+    }
+
+    @Override
+    public boolean canPipeConnect(WorldAccess world, BlockPos pos, BlockState state, Direction dir) {
+        return state.get(FACING) == dir;
+    }
+
+    @Nullable
+    @Override
+    public BlockState getPlacementState(ItemPlacementContext ctx) {
+        var sidePos = ctx.getBlockPos().offset(ctx.getSide(), -1);
+        var state = ctx.getWorld().getBlockState(sidePos);
+        if (state.getBlock() instanceof PipeConnectable connectable && connectable.canPipeConnect(ctx.getWorld(), sidePos, state, ctx.getSide())) {
+            return this.getDefaultState().with(FACING, ctx.getSide().getOpposite());
+        }
+        return this.getDefaultState().with(FACING, ctx.getSide());
+    }
+
+    @Override
+    protected BlockState getStateForNeighborUpdate(BlockState state, Direction direction, BlockState neighborState, WorldAccess world, BlockPos pos, BlockPos neighborPos) {
+        tickWater(state, world, pos);
+        return state;
+    }
+
+    @Override
+    protected void appendProperties(StateManager.Builder<Block, BlockState> builder) {
+        super.appendProperties(builder);
+        builder.add(WATERLOGGED, FACING);
+    }
+
+    @Override
+    public @Nullable ElementHolder createElementHolder(ServerWorld world, BlockPos pos, BlockState initialBlockState) {
+        return new Model(initialBlockState);
+    }
+
+    @Override
+    public boolean tickElementHolder(ServerWorld world, BlockPos pos, BlockState initialBlockState) {
+        return true;
+    }
+
+    @Nullable
+    @Override
+    public BlockEntity createBlockEntity(BlockPos pos, BlockState state) {
+        return new PortableFluidTankBlockEntity(pos, state);
+    }
+
+    @Nullable
+    @Override
+    public <T extends BlockEntity> BlockEntityTicker<T> getTicker(World world, BlockState state, BlockEntityType<T> type) {
+        return PortableFluidTankBlockEntity::tick;
+    }
+
+    @Override
+    public BlockState getPolymerBreakEventBlockState(BlockState state, ServerPlayerEntity player) {
+        return Blocks.COPPER_BLOCK.getDefaultState();
+    }
+
+    public static final class Model extends BlockModel {
+        private final ItemDisplayElement main;
+
+        private Model(BlockState state) {
+            this.main = ItemDisplayElementUtil.createSimple(state.getBlock().asItem());
+            this.main.setScale(new Vector3f(2f));
+            updateStatePos(state);
+            this.addElement(this.main);
+        }
+
+        private void updateStatePos(BlockState state) {
+            var dir = state.get(FACING);
+            float p = 0;
+            float y = 0;
+
+            if (dir.getAxis() != Direction.Axis.Y) {
+                p = 90;
+                y = dir.asRotation();
+            } else if (dir == Direction.DOWN) {
+                p = 180;
+            }
+
+
+            this.main.setYaw(y);
+            this.main.setPitch(p);
+        }
+
+        @Override
+        public void notifyUpdate(HolderAttachment.UpdateType updateType) {
+            super.notifyUpdate(updateType);
+            if (updateType == BlockAwareAttachment.BLOCK_STATE_UPDATE) {
+                updateStatePos(this.blockState());
+            }
+        }
+    }
+}
diff --git a/src/main/java/eu/pb4/polyfactory/block/fluids/PortableFluidTankBlockEntity.java b/src/main/java/eu/pb4/polyfactory/block/fluids/PortableFluidTankBlockEntity.java
@@ -0,0 +1,91 @@
+package eu.pb4.polyfactory.block.fluids;
+
+import eu.pb4.polyfactory.block.BlockHeat;
+import eu.pb4.polyfactory.block.FactoryBlockEntities;
+import eu.pb4.polyfactory.fluid.FluidContainer;
+import eu.pb4.polyfactory.item.FactoryDataComponents;
+import eu.pb4.polyfactory.item.component.FluidComponent;
+import net.fabricmc.fabric.api.transfer.v1.fluid.FluidConstants;
+import net.minecraft.block.BlockState;
+import net.minecraft.block.entity.BlockEntity;
+import net.minecraft.component.ComponentMap;
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NbtCompound;
+import net.minecraft.registry.RegistryWrapper;
+import net.minecraft.server.world.ServerWorld;
+import net.minecraft.util.ItemScatterer;
+import net.minecraft.util.math.BlockPos;
+import net.minecraft.util.math.Direction;
+import net.minecraft.world.World;
+import org.jetbrains.annotations.Nullable;
+
+public class PortableFluidTankBlockEntity extends BlockEntity implements FluidInputOutput.ContainerBased {
+    public static final long CAPACITY = FluidConstants.BLOCK * 3;
+    private final FluidContainer container = new FluidContainer(CAPACITY, this::onFluidChanged);
+    private float blockTemperature = 0;
+
+    public PortableFluidTankBlockEntity(BlockPos pos, BlockState state) {
+        super(FactoryBlockEntities.PORTABLE_FLUID_TANK, pos, state);
+    }
+
+    public FluidContainer getFluidContainer() {
+        return this.container;
+    }
+
+    @Override
+    protected void writeNbt(NbtCompound nbt, RegistryWrapper.WrapperLookup registryLookup) {
+        super.writeNbt(nbt, registryLookup);
+        nbt.put("fluid", this.container.toNbt(registryLookup));
+    }
+
+    @Override
+    protected void readNbt(NbtCompound nbt, RegistryWrapper.WrapperLookup registryLookup) {
+        super.readNbt(nbt, registryLookup);
+        this.container.fromNbt(registryLookup, nbt, "fluid");
+    }
+    @Override
+    protected void readComponents(ComponentsAccess components) {
+        super.readComponents(components);
+        var f = components.get(FactoryDataComponents.FLUID);
+        if (f != null) {
+            this.container.clear();
+            f.extractTo(this.container);
+        }
+    }
+
+    @Override
+    protected void addComponents(ComponentMap.Builder componentMapBuilder) {
+        super.addComponents(componentMapBuilder);
+        componentMapBuilder.add(FactoryDataComponents.FLUID, FluidComponent.copyFrom(this.container));
+    }
+
+    @Override
+    public void removeFromCopiedStackNbt(NbtCompound nbt) {
+        super.removeFromCopiedStackNbt(nbt);
+        nbt.remove("fluid");
+    }
+    @Override
+    public FluidContainer getFluidContainer(Direction direction) {
+        return this.container;
+    }
+
+    @Override
+    public @Nullable FluidContainer getMainFluidContainer() {
+        return this.container;
+    }
+
+    private void onFluidChanged() {
+        this.markDirty();
+    }
+    public static <T extends BlockEntity> void tick(World world, BlockPos pos, BlockState state, T t) {
+        if (!(t instanceof PortableFluidTankBlockEntity tank)) {
+            return;
+        }
+        tank.blockTemperature = BlockHeat.get(world.getBlockState(pos.down())) + tank.container.fluidTemperature();
+        tank.container.tick((ServerWorld) world, pos, tank.blockTemperature, tank::dropItem);
+    }
+
+    private void dropItem(ItemStack stack) {
+        ItemScatterer.spawn(world, this.pos.getX() + 0.5, this.pos.getY() + 0.5, this.pos.getZ() + 0.5, stack);
+    }
+}
diff --git a/src/main/java/eu/pb4/polyfactory/block/fluids/PumpBlockEntity.java b/src/main/java/eu/pb4/polyfactory/block/fluids/PumpBlockEntity.java
@@ -17,7 +17,7 @@
 import net.minecraft.util.math.Direction;
 import net.minecraft.world.World;
 
-public class PumpBlockEntity extends PipeLikeBlockEntity implements FluidInput.ContainerBased, DebugTextProvider {
+public class PumpBlockEntity extends PipeLikeBlockEntity {
     private double speed;
 
     public PumpBlockEntity(BlockPos pos, BlockState state) {

diff --git a/src/main/java/eu/pb4/polyfactory/block/mechanical/machines/crafting/MixerBlockEntity.java b/src/main/java/eu/pb4/polyfactory/block/mechanical/machines/crafting/MixerBlockEntity.java
@@ -400,6 +400,16 @@ public FluidContainer getFluidContainer(Direction direction) {
         return this.fluidContainer;
     }
 
+    @Override
+    public @Nullable FluidContainer getMainFluidContainer() {
+        return this.fluidContainer;
+    }
+
+    @Override
+    public Text getFilledStateText() {
+        return null;
+    }
+
     private class Gui extends SimpleGui {
         private static final Text CURRENT_HEAT = Text.translatable("text.polyfactory.current_heat").styled(x -> x.withItalic(false));
         private int lastFluidUpdate = -1;