package net.minecraftforge.fluids; import net.minecraft.core.BlockPos; import net.minecraft.core.Direction; import net.minecraft.world.level.Level; import net.minecraft.world.level.block.Blocks; import net.minecraft.world.level.block.LiquidBlock; import net.minecraft.world.level.block.state.BlockState; import net.minecraft.world.level.material.FluidState; import net.minecraftforge.common.ForgeMod; import net.minecraftforge.event.ForgeEventFactory; import java.util.ArrayList; import java.util.Collections; import java.util.HashMap; import java.util.List; import java.util.Map; import java.util.function.Function; /** * A registry which defines the interactions a source fluid can have with its * surroundings. Each possible flow direction is checked for all interactions with * the source. * *

Fluid interactions mimic the behavior of {@code LiquidBlock#shouldSpreadLiquid}. * As such, all directions, besides {@link Direction#DOWN} is tested and then replaced. * Any fluids which cause a change in the down interaction must be handled in * {@code FlowingFluid#spreadTo} and not by this interaction manager. */ public final class FluidInteractionRegistry { private static final Map> INTERACTIONS = new HashMap<>(); /** * Adds an interaction between a source and its surroundings. * * @param source the source of the interaction, this will be replaced if the interaction occurs * @param interaction the interaction data to check and perform */ public static synchronized void addInteraction(FluidType source, InteractionInformation interaction) { INTERACTIONS.computeIfAbsent(source, s -> new ArrayList<>()).add(interaction); } /** * Performs all potential fluid interactions at a given position. * *

Note: Only the first interaction check that succeeds will occur. * * @param level the level the interactions take place in * @param pos the position of the source fluid * @return {@code true} if an interaction took place, {@code false} otherwise */ public static boolean canInteract(Level level, BlockPos pos) { FluidState state = level.getFluidState(pos); for (Direction direction : LiquidBlock.POSSIBLE_FLOW_DIRECTIONS) { BlockPos relativePos = pos.relative(direction.getOpposite()); List interactions = INTERACTIONS.getOrDefault(state.getFluidType(), Collections.emptyList()); for (InteractionInformation interaction : interactions) { if (interaction.predicate().test(level, pos, relativePos, state)) { interaction.interaction().interact(level, pos, relativePos, state); return true; } } } return false; } static { // Lava + Water = Obsidian (Source Lava) / Cobblestone (Flowing Lava) addInteraction(ForgeMod.LAVA_TYPE.get(), new InteractionInformation( ForgeMod.WATER_TYPE.get(), fluidState -> fluidState.isSource() ? Blocks.OBSIDIAN.defaultBlockState() : Blocks.COBBLESTONE.defaultBlockState() )); // Lava + Soul Soil (Below) + Blue Ice = Basalt addInteraction(ForgeMod.LAVA_TYPE.get(), new InteractionInformation( (level, currentPos, relativePos, currentState) -> level.getBlockState(currentPos.below()).is(Blocks.SOUL_SOIL) && level.getBlockState(relativePos).is(Blocks.BLUE_ICE), Blocks.BASALT.defaultBlockState() )); } /** * Holds the interaction data for a given source type on when to succeed * and what to perform. * * @param predicate a test to see whether an interaction can occur * @param interaction the interaction to perform */ public record InteractionInformation(HasFluidInteraction predicate, FluidInteraction interaction) { /** * Constructor which checks the surroundings fluids for a specific type * and then transforms the source state into a block. * * @param type the type of the fluid that must be surrounding the source * @param state the state of the block replacing the source */ public InteractionInformation(FluidType type, BlockState state) { this(type, fluidState -> state); } /** * Constructor which transforms the source state into a block. * * @param predicate a test to see whether an interaction can occur * @param state the state of the block replacing the source */ public InteractionInformation(HasFluidInteraction predicate, BlockState state) { this(predicate, fluidState -> state); } /** * Constructor which checks the surroundings fluids for a specific type * and then transforms the source state into a block. * * @param type the type of the fluid that must be surrounding the source * @param getState a function to transform the source fluid into a block state */ public InteractionInformation(FluidType type, Function getState) { this((level, currentPos, relativePos, currentState) -> level.getFluidState(relativePos).getFluidType() == type, getState); } /** * Constructor which transforms the source state into a block. * * @param predicate a test to see whether an interaction can occur * @param getState a function to transform the source fluid into a block state */ public InteractionInformation(HasFluidInteraction predicate, Function getState) { this(predicate, (level, currentPos, relativePos, currentState) -> { level.setBlockAndUpdate(currentPos, ForgeEventFactory.fireFluidPlaceBlockEvent(level, currentPos, currentPos, getState.apply(currentState))); level.levelEvent(1501, currentPos, 0); }); } } /** * An interface which tests whether a source fluid can interact with its * surroundings. */ @FunctionalInterface public interface HasFluidInteraction { /** * Returns whether the interaction can occur. * * @param level the level the interaction takes place in * @param currentPos the position of the source * @param relativePos a position surrounding the source * @param currentState the state of the fluid surrounding the source * @return {@code true} if an interaction can occur, {@code false} otherwise */ boolean test(Level level, BlockPos currentPos, BlockPos relativePos, FluidState currentState); } /** * An interface which performs an interaction for a source. */ @FunctionalInterface public interface FluidInteraction { /** * Performs the interaction between the source and the surrounding data. * * @param level the level the interaction takes place in * @param currentPos the position of the source * @param relativePos a position surrounding the source * @param currentState the state of the fluid surrounding the source */ void interact(Level level, BlockPos currentPos, BlockPos relativePos, FluidState currentState); } }