Create a Fluid Flow API

library/fluid/build.gradle

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

library/fluid/fluid-flow/build.gradle

@@ -0,0 +1,12 @@
+plugins {
+	id("qsl.module")
+}
+
+qslModule {
+	moduleName = "fluid-flow"
+	version = "1.0.0"
+	library = "fluid"
+	coreDependencies([
+			"qsl_base"
+	])
+}

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

@@ -0,0 +1,118 @@
+/*
+ * 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.fluidflow.api;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import org.jetbrains.annotations.Nullable;
+import org.quiltmc.qsl.base.api.event.Event;
+
+import net.minecraft.block.Block;
+import net.minecraft.block.BlockState;
+import net.minecraft.util.Pair;
+import net.minecraft.util.math.BlockPos;
+import net.minecraft.util.math.Direction;
+import net.minecraft.world.World;
+
+
+public final class FluidFlowEvents {
+	private FluidFlowEvents() {
+	}
+
+	// Flowing Block to Interacting Block to Direction to Event
+	private static final Map<Block, Map<Block, Map<Direction, Event<FluidFlowInteractionCallback>>>> EVENT_MAP = new HashMap<>();
+
+	/**
+	 * Registers a new event on a fluid flow. The same two blocks can register a different event for different directions, but the same directions will run the event that was registered first.
+	 *
+	 * @param flowingBlock          The fluid block that flowed.
+	 * @param interactionBlock      The block in one of the {@code interactionDirections}.
+	 * @param interactionDirections The direction to search for {@code interactionBlock}.
+	 * @param interactionEvent      The event to run when the conditions are met.
+	 */
+	public static void register(Block flowingBlock, Block interactionBlock, Direction[] interactionDirections, FluidFlowInteractionCallback interactionEvent) {
+		Map<Block, Map<Direction, Event<FluidFlowInteractionCallback>>> flowBlockEvents = EVENT_MAP.computeIfAbsent(flowingBlock, flowing -> new HashMap<>());
+		Map<Direction, Event<FluidFlowInteractionCallback>> interactionEvents = flowBlockEvents.computeIfAbsent(interactionBlock, interacting -> new HashMap<>());
+
+		// Create events for all the different directions for the specified blocks
+		if (interactionEvents.isEmpty()) {
+			for (Direction direction : Direction.values()) {
+				interactionEvents.put(direction, Event.create(FluidFlowInteractionCallback.class, fluidFlowInteractionEvents -> (flowingBlockState, interactingBlockState, flowPos, world) -> {
+					for (FluidFlowInteractionCallback event : fluidFlowInteractionEvents) {
+						if (!event.onFlow(flowingBlockState, interactingBlockState, flowPos, world)) {
+							return false;
+						}
+					}
+
+					return true;
+				}));
+			}
+		}
+
+		// Register the new event callbacks
+		for (Map.Entry<Direction, Event<FluidFlowInteractionCallback>> pair : interactionEvents.entrySet()) {
+			for (Direction direction : interactionDirections) {
+				if (pair.getKey() == direction) {
+					pair.getValue().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.
+	 * @param interactionDirection The interaction direction
+	 * @return An event if the conditions are met, otherwise {@code null}
+	 */
+	public static @Nullable Event<FluidFlowInteractionCallback> getEvent(Block flowingBlock, Block interactionBlock, Direction interactionDirection) {
+		if (EVENT_MAP.containsKey(flowingBlock)) {
+			Map<Block, Map<Direction, Event<FluidFlowInteractionCallback>>> flowBlockEvents = EVENT_MAP.get(flowingBlock);
+
+			if (flowBlockEvents.containsKey(interactionBlock)) {
+				Map<Direction, Event<FluidFlowInteractionCallback>> interactionEvents = flowBlockEvents.get(interactionBlock);
+
+				for (Map.Entry<Direction, Event<FluidFlowInteractionCallback>> pair : interactionEvents.entrySet()) {
+					if (pair.getKey() == interactionDirection) {
+						return pair.getValue();
+					}
+				}
+			}
+		}
+
+		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 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 was successful, and {@code true} if it was unsuccessful (don't blame us its minecraft that does this).
+		 */
+		boolean onFlow(BlockState flowingBlockState, BlockState interactingBlockState, BlockPos flowPos, World world);
+	}
+}

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

@@ -0,0 +1,53 @@
+/*
+ * 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.fluidflow.mixin;
+
+import org.quiltmc.qsl.base.api.event.Event;
+import org.quiltmc.qsl.fluidflow.api.FluidFlowEvents;
+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;
+
+
+@Mixin(FluidBlock.class)
+public class FluidBlockMixin extends Block {
+	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 : Direction.values()) {
+			Event<FluidFlowEvents.FluidFlowInteractionCallback> event = FluidFlowEvents.getEvent(this, world.getBlockState(pos.offset(direction)).getBlock(), direction);
+
+			if (event != null) {
+				if (!event.invoker().onFlow(state, world.getBlockState(pos.offset(direction)), pos, world)) {
+					cir.setReturnValue(false);
+					return;
+				}
+			}
+		}
+	}
+}

library/fluid/fluid-flow/src/main/resources/fabric.mod.json

@@ -0,0 +1,41 @@
+{
+  "schemaVersion": 1,
+  "id": "quilt_fluid_flow",
+  "name": "Quilt Tags API",
+  "version": "${version}",
+  "environment": "*",
+  "license": "Apache-2.0",
+  "icon": "assets/quilt_fluid_flow/icon.png",
+  "contact": {
+    "homepage": "https://quiltmc.org",
+    "issues": "https://github.com/QuiltMC/quilt-standard-libraries/issues",
+    "sources": "https://github.com/QuiltMC/quilt-standard-libraries"
+  },
+  "authors": [
+    "QuiltMC"
+  ],
+  "depends": {
+    "fabricloader": ">=0.12",
+    "minecraft": ">=1.18.2-alpha.22.3.a"
+  },
+  "description": "Events for flowing fluids.",
+  "mixins": [
+    "quilt_fluid_flow.mixins.json"
+  ],
+  "custom": {
+    "modmenu": {
+      "badges": [
+        "library"
+      ],
+      "parent": {
+        "id": "qsl",
+        "name": "Quilt Standard Libraries",
+        "description": "A set of libraries to assist in making Quilt mods.",
+        "icon": "assets/quilt_fluid_flow/icon.png",
+        "badges": [
+          "library"
+        ]
+      }
+    }
+  }
+}

library/fluid/fluid-flow/src/main/resources/quilt_fluid_flow.mixins.json

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

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

@@ -0,0 +1,37 @@
+/*
+ * 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.fluidflow;
+
+import org.quiltmc.qsl.fluidflow.api.FluidFlowEvents;
+
+import net.minecraft.block.Blocks;
+import net.minecraft.sound.SoundCategory;
+import net.minecraft.sound.SoundEvents;
+import net.minecraft.util.math.Direction;
+
+import net.fabricmc.api.ModInitializer;
+
+public class FluidFlowEventTests implements ModInitializer {
+	@Override
+	public void onInitialize() {
+		FluidFlowEvents.register(Blocks.WATER, Blocks.BLUE_ICE, new Direction[]{Direction.DOWN}, (flowingBlockState, interactingBlockState, flowPos, world) -> {
+			world.setBlockState(flowPos, Blocks.ICE.getDefaultState());
+			world.playSound(null, flowPos, SoundEvents.BLOCK_GLASS_PLACE, SoundCategory.BLOCKS, 1, 1);
+			return false;
+		});
+	}
+}

library/fluid/fluid-flow/src/testmod/resources/fabric.mod.json

@@ -0,0 +1,16 @@
+{
+  "schemaVersion": 1,
+  "id": "quilt_fluid_flow_testmod",
+  "name": "Quilt Fluid Flow API Test Mod",
+  "version": "1.0.0",
+  "environment": "*",
+  "license": "Apache-2.0",
+  "depends": {
+    "quilt_fluid_flow": "*"
+  },
+  "entrypoints": {
+    "main": [
+      "org.quiltmc.qsl.fluidflow.FluidFlowEventTests"
+    ]
+  }
+}

settings.gradle

@@ -31,6 +31,7 @@ library("core")
 library("block")
 library("data")
 library("item")
+library("fluid")
 library("command")
 
 def library(String library) {