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,16 @@
+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."
+	library = "fluid"
+	moduleDependencies {
+		core {
+			api("qsl_base")
+		}
+	}
+}

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

@@ -0,0 +1,89 @@
+/*
+ * 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 org.quiltmc.qsl.base.api.event.Event;
+
+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;
+
+
+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) {
+		Map<Block, Event<FluidFlowInteractionCallback>> 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) {
+		Map<Block, Event<FluidFlowInteractionCallback>> 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 fluidToInteractingBlockDirection 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 fluidToInteractingBlockDirection, BlockPos flowPos, World world);
+	}
+}

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

@@ -0,0 +1,55 @@
+/*
+ * 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.quiltmc.qsl.base.api.event.Event;
+import org.quiltmc.qsl.fluid.flow.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 {
+	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) {
+			Event<FluidFlowEvents.FluidFlowInteractionCallback> 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,13 @@
+{
+  "required": true,
+  "package": "org.quiltmc.qsl.fluid.flow.mixin",
+  "compatibilityLevel": "JAVA_17",
+  "mixins": [
+    "FluidBlockMixin"
+  ],
+  "client": [
+  ],
+  "injectors": {
+    "defaultRequire": 1
+  }
+}

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

@@ -0,0 +1,42 @@
+/*
+ * 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 org.quiltmc.loader.api.ModContainer;
+import org.quiltmc.qsl.base.api.entrypoint.ModInitializer;
+import org.quiltmc.qsl.fluid.flow.api.FluidFlowEvents;
+
+import net.minecraft.block.Blocks;
+import net.minecraft.sound.SoundCategory;
+import net.minecraft.sound.SoundEvents;
+import net.minecraft.util.math.Direction;
+
+
+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,14 @@
+{
+  "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"
+  }
+}

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"
+    ]
+  }
+}

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

@@ -2,10 +2,10 @@
   "schema_version": 1,
   "quilt_loader": {
     "group": "org.quiltmc.qsl",
-    "id": "quilt_data_testmod",
+    "id": "quilt_worldgen_testmod",
     "version": "1.0.0",
     "metadata": {
-      "name": "Quilt Data Library Test Mod",
+      "name": "Quilt Worldgen Library Test Mod",
       "license": "Apache-2.0"
     },
     "intermediate_mappings": "net.fabricmc:intermediary",

settings.gradle

@@ -29,6 +29,7 @@ includeBuild("build-logic")
 library("core")
 library("block")
 library("data")
+library("fluid")
 library("gui")
 library("item")
 library("management")