Create a Fluid Flow API

library/fluid/build.gradle

@@ -0,0 +1,7 @@
+plugins {
+	id("qsl.library")
+}
+
+qslLibrary {
+	libraryName = "fluid"
+}

library/fluid/fluid_flow/build.gradle

@@ -0,0 +1,15 @@
+plugins {
+	id("qsl.module")
+}
+
+qslModule {
+	name = "Quilt Fluid Flow Event API"
+	moduleName = "fluid_flow"
+	id = "quilt_fluid_flow"
+	description = "Adds events for when fluids flow around other blocks."
+	moduleDependencies {
+		core {
+			api("qsl_base")
+		}
+	}
+}

library/fluid/fluid_flow/src/main/java/org/quiltmc/qsl/fluid/flow/api/FluidFlowEvents.java

@@ -0,0 +1,87 @@
+/*
+ * Copyright 2022 QuiltMC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.quiltmc.qsl.fluid.flow.api;
+
+import java.util.Map;
+
+import it.unimi.dsi.fastutil.objects.Object2ObjectOpenHashMap;
+import org.jetbrains.annotations.Nullable;
+
+import net.minecraft.block.Block;
+import net.minecraft.block.BlockState;
+import net.minecraft.util.math.BlockPos;
+import net.minecraft.util.math.Direction;
+import net.minecraft.world.World;
+
+import org.quiltmc.qsl.base.api.event.Event;
+
+public final class FluidFlowEvents {
+	private FluidFlowEvents() {}
+
+	// Flowing Block to Interacting Block to Event
+	private static final Map<Block, Map<Block, Event<FluidFlowInteractionCallback>>> EVENT_MAP = new Object2ObjectOpenHashMap<>();
+
+	/**
+	 * Registers a new event on a fluid flow.
+	 *
+	 * @param flowingBlock     the fluid block that flowed
+	 * @param interactionBlock the block in one of the {@code interactionDirections}
+	 * @param interactionEvent the event to run when the conditions are met
+	 */
+	public static void register(Block flowingBlock, Block interactionBlock, FluidFlowInteractionCallback interactionEvent) {
+		var flowBlockEvents = EVENT_MAP.computeIfAbsent(flowingBlock, flowing -> new Object2ObjectOpenHashMap<>());
+		flowBlockEvents.computeIfAbsent(interactionBlock, (block) -> Event.create(FluidFlowInteractionCallback.class, fluidFlowInteractionEvents -> (flowingBlockState, interactingBlockState, interactionDirection, flowPos, world) -> {
+			for (FluidFlowInteractionCallback event : fluidFlowInteractionEvents) {
+				if (!event.onFlow(flowingBlockState, interactingBlockState, interactionDirection, flowPos, world)) {
+					return false;
+				}
+			}
+
+			return true;
+		})).register(interactionEvent);
+	}
+
+	/**
+	 * Gets the event from the following blocks and direction.
+	 *
+	 * @param flowingBlock     the fluid block that flowed
+	 * @param interactionBlock the block it interacts with
+	 * @return an event if the conditions are met, otherwise {@code null}
+	 */
+	public static @Nullable Event<FluidFlowInteractionCallback> getEvent(Block flowingBlock, Block interactionBlock) {
+		var flowBlockEvents = EVENT_MAP.get(flowingBlock);
+		if (flowBlockEvents != null) {
+			return flowBlockEvents.get(interactionBlock);
+		}
+
+		return null;
+	}
+
+	public interface FluidFlowInteractionCallback {
+		/**
+		 * An event run when a fluid flows next to a block.
+		 *
+		 * @param flowingBlockState     The block state of the fluid block.
+		 * @param interactingBlockState The block state of the interacting block.
+		 * @param interactionDirection  The direction from the flowingBlockState to the interactingBlockState.
+		 * @param flowPos               The position in the world that the fluid flowed into.
+		 * @param world                 The world the event took place in.
+		 * @return {@code false} if the event successfully ran, and {@code true} if it was unsuccessful or did not run.
+		 */
+		boolean onFlow(BlockState flowingBlockState, BlockState interactingBlockState, Direction interactionDirection, BlockPos flowPos, World world);
+	}
+}

library/fluid/fluid_flow/src/main/java/org/quiltmc/qsl/fluid/flow/mixin/FluidBlockMixin.java

@@ -0,0 +1,54 @@
+/*
+ * Copyright 2022 QuiltMC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.quiltmc.qsl.fluid.flow.mixin;
+
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.Inject;
+import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable;
+
+import net.minecraft.block.Block;
+import net.minecraft.block.BlockState;
+import net.minecraft.block.FluidBlock;
+import net.minecraft.util.math.BlockPos;
+import net.minecraft.util.math.Direction;
+import net.minecraft.world.World;
+
+import org.quiltmc.qsl.fluid.flow.api.FluidFlowEvents;
+
+@Mixin(FluidBlock.class)
+public class FluidBlockMixin extends Block {
+	private static final Direction[] DIRECTIONS = Direction.values();
+
+	public FluidBlockMixin(Settings settings) {
+		super(settings);
+	}
+
+	@Inject(method = "receiveNeighborFluids", at = @At("HEAD"), cancellable = true)
+	private void receiveNeighborFluids(World world, BlockPos pos, BlockState state, CallbackInfoReturnable<Boolean> cir) {
+		for (Direction direction : DIRECTIONS) {
+			var event = FluidFlowEvents.getEvent(this, world.getBlockState(pos.offset(direction)).getBlock());
+
+			if (event != null) {
+				if (!event.invoker().onFlow(state, world.getBlockState(pos.offset(direction)), direction, pos, world)) {
+					cir.setReturnValue(false);
+					return;
+				}
+			}
+		}
+	}
+}

library/fluid/fluid_flow/src/main/resources/quilt_fluid_flow.mixins.json

@@ -0,0 +1,11 @@
+{
+  "required": true,
+  "package": "org.quiltmc.qsl.fluid.flow.mixin",
+  "compatibilityLevel": "JAVA_17",
+  "mixins": [
+    "FluidBlockMixin"
+  ],
+  "injectors": {
+    "defaultRequire": 1
+  }
+}

library/fluid/fluid_flow/src/testmod/java/org/quiltmc/qsl/fluid/flow/FluidFlowEventTests.java

@@ -0,0 +1,41 @@
+/*
+ * Copyright 2022 QuiltMC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.quiltmc.qsl.fluid.flow;
+
+import net.minecraft.block.Blocks;
+import net.minecraft.sound.SoundCategory;
+import net.minecraft.sound.SoundEvents;
+import net.minecraft.util.math.Direction;
+
+import org.quiltmc.loader.api.ModContainer;
+import org.quiltmc.qsl.base.api.entrypoint.ModInitializer;
+import org.quiltmc.qsl.fluid.flow.api.FluidFlowEvents;
+
+public class FluidFlowEventTests implements ModInitializer {
+	@Override
+	public void onInitialize(ModContainer container) {
+		FluidFlowEvents.register(Blocks.WATER, Blocks.BLUE_ICE, (flowingBlockState, interactingBlockState, interactionDirection, flowPos, world) -> {
+			if (interactionDirection == Direction.DOWN) {
+				world.setBlockState(flowPos, Blocks.ICE.getDefaultState());
+				world.playSound(null, flowPos, SoundEvents.BLOCK_GLASS_PLACE, SoundCategory.BLOCKS, 1, 1);
+				return false;
+			}
+
+			return true;
+		});
+	}
+}

library/fluid/fluid_flow/src/testmod/resources/quilt.mod.json

@@ -0,0 +1,19 @@
+{
+  "schema_version": 1,
+  "quilt_loader": {
+    "group": "org.quiltmc.qsl",
+    "id": "quilt_fluid_flow_testmod",
+    "version": "1.0.0",
+    "metadata": {
+      "name": "Quilt Flow Flow Event Test Mod",
+      "license": "Apache-2.0"
+    },
+    "intermediate_mappings": "net.fabricmc:intermediary",
+    "load_type": "always",
+    "entrypoints": {
+      "init": [
+        "org.quiltmc.qsl.fluid.flow.FluidFlowEventTests"
+      ]
+    }
+  }
+}

library/fluid/src/testmod/resources/quilt.mod.json

@@ -0,0 +1,23 @@
+{
+  "schema_version": 1,
+  "quilt_loader": {
+    "group": "org.quiltmc.qsl",
+    "id": "quilt_fluid_testmod",
+    "version": "1.0.0",
+    "metadata": {
+      "name": "Quilt Fluid Library Test Mod",
+      "license": "Apache-2.0"
+    },
+    "intermediate_mappings": "net.fabricmc:intermediary",
+    "load_type": "always",
+    "entrypoints": {
+      "init": [
+        "org.quiltmc.qsl.fluid.flow.FluidFlowEventTests"
+      ]
+    },
+    "depends": [
+      "quilt_loader",
+      "quilt_fluid_flow"
+    ]
+  }
+}

settings.gradle

@@ -30,6 +30,7 @@ library("core")
 library("block")
 library("data")
 library("entity")
+library("fluid")
 library("rendering")
 library("gui")
 library("item")