modlib/minetest/liquid.lua

-- Localize globals
local math, minetest, modlib, pairs = math, minetest, modlib, pairs

-- Set environment
local _ENV = ...
setfenv(1, _ENV)

liquid_level_max = 8
--+ Calculates the corner levels of a flowingliquid node
--> 4 corner levels from -0.5 to 0.5 as list of `modlib.vector`
function get_liquid_corner_levels(pos)
	local node = minetest.get_node(pos)
	local def = minetest.registered_nodes[node.name]
	local source, flowing = def.liquid_alternative_source, node.name
	local range = def.liquid_range or liquid_level_max
	local neighbors = {}
	for x = -1, 1 do
		neighbors[x] = {}
		for z = -1, 1 do
			local neighbor_pos = {x = pos.x + x, y = pos.y, z = pos.z + z}
			local neighbor_node = minetest.get_node(neighbor_pos)
			local level
			if neighbor_node.name == source then
				level = 1
			elseif neighbor_node.name == flowing then
				local neighbor_level = neighbor_node.param2 % 8
				level = (math.max(0, neighbor_level - liquid_level_max + range) + 0.5) / range
			end
			neighbor_pos.y = neighbor_pos.y + 1
			local node_above = minetest.get_node(neighbor_pos)
			neighbors[x][z] = {
				air = neighbor_node.name == "air",
				level = level,
				above_is_same_liquid = node_above.name == flowing or node_above.name == source
			}
		end
	end
	local function get_corner_level(x, z)
		local air_neighbor
		local levels = 0
		local neighbor_count = 0
		for nx = x - 1, x do
			for nz = z - 1, z do
				local neighbor = neighbors[nx][nz]
				if neighbor.above_is_same_liquid then
					return 1
				end
				local level = neighbor.level
				if level then
					if level == 1 then
						return 1
					end
					levels = levels + level
					neighbor_count = neighbor_count + 1
				elseif neighbor.air then
					if air_neighbor then
						return 0.02
					end
					air_neighbor = true
				end
			end
		end
		if neighbor_count == 0 then
			return 0
		end
		return levels / neighbor_count
	end
	local corner_levels = {
		{0, nil, 0},
		{1, nil, 0},
		{1, nil, 1},
		{0, nil, 1}
	}
	for index, corner_level in pairs(corner_levels) do
		corner_level[2] = get_corner_level(corner_level[1], corner_level[3])
		corner_levels[index] = modlib.vector.subtract_scalar(modlib.vector.new(corner_level), 0.5)
	end
	return corner_levels
end

flowing_downwards = modlib.vector.new{0, -1, 0}
--+ Calculates the flow direction of a flowingliquid node
--> `modlib.minetest.flowing_downwards = modlib.vector.new{0, -1, 0}` if only flowing downwards
--> surface direction as `modlib.vector` else
function get_liquid_flow_direction(pos)
	local corner_levels = get_liquid_corner_levels(pos)
	local max_level = corner_levels[1][2]
	for index = 2, 4 do
		local level = corner_levels[index][2]
		if level > max_level then
			max_level = level
		end
	end
	local dir = modlib.vector.new{0, 0, 0}
	local count = 0
	for max_level_index, corner_level in pairs(corner_levels) do
		if corner_level[2] == max_level then
			for offset = 1, 3 do
				local index = (max_level_index + offset - 1) % 4 + 1
				local diff = corner_level - corner_levels[index]
				if diff[2] ~= 0 then
					diff[1] = diff[1] * diff[2]
					diff[3] = diff[3] * diff[2]
					if offset == 3 then
						diff = modlib.vector.divide_scalar(diff, math.sqrt(2))
					end
					dir = dir + diff
					count = count + 1
				end
			end
		end
	end
	if count ~= 0 then
		dir = modlib.vector.divide_scalar(dir, count)
	end
	if dir == modlib.vector.new{0, 0, 0} then
		if minetest.get_node(pos).param2 % 32 > 7 then
			return flowing_downwards
		end
	end
	return dir
end