2020-12-19 15:31:37 +01:00
|
|
|
max_wear = 2 ^ 16 - 1
|
2020-09-27 16:55:41 +02:00
|
|
|
function override(function_name, function_builder)
|
|
|
|
local func = minetest[function_name]
|
|
|
|
minetest["original_" .. function_name] = func
|
|
|
|
minetest[function_name] = function_builder(func)
|
|
|
|
end
|
|
|
|
|
|
|
|
-- TODO fix modlib.minetest.get_gametime() messing up responsible "mod" determined by engine on crash
|
|
|
|
get_gametime = minetest.get_gametime
|
|
|
|
local get_gametime_initialized
|
|
|
|
local function get_gametime_init(dtime)
|
|
|
|
if get_gametime_initialized then
|
|
|
|
-- if the profiler is being used, the globalstep can't be unregistered
|
|
|
|
return
|
|
|
|
end
|
|
|
|
get_gametime_initialized = true
|
|
|
|
assert(dtime == 0)
|
|
|
|
local gametime = minetest.get_gametime()
|
|
|
|
assert(gametime)
|
|
|
|
function modlib.minetest.get_gametime()
|
|
|
|
local imprecise_gametime = minetest.get_gametime()
|
|
|
|
if imprecise_gametime > gametime then
|
|
|
|
minetest.log("warning", "modlib.minetest.get_gametime(): Called after increment and before first globalstep")
|
|
|
|
return imprecise_gametime
|
|
|
|
end
|
|
|
|
return gametime
|
|
|
|
end
|
|
|
|
for index, globalstep in pairs(minetest.registered_globalsteps) do
|
|
|
|
if globalstep == get_gametime_init then
|
|
|
|
table.remove(minetest.registered_globalsteps, index)
|
|
|
|
break
|
|
|
|
end
|
|
|
|
end
|
|
|
|
-- globalsteps of mods which depend on modlib will execute after this
|
|
|
|
minetest.register_globalstep(function(dtime)
|
|
|
|
gametime = gametime + dtime
|
|
|
|
end)
|
|
|
|
end
|
|
|
|
minetest.register_globalstep(get_gametime_init)
|
|
|
|
|
2020-02-09 01:39:54 +01:00
|
|
|
delta_times={}
|
|
|
|
delays={}
|
|
|
|
callbacks={}
|
|
|
|
function register_globalstep(interval, callback)
|
|
|
|
if type(callback) ~= "function" then
|
|
|
|
return
|
|
|
|
end
|
|
|
|
table.insert(delta_times, 0)
|
|
|
|
table.insert(delays, interval)
|
|
|
|
table.insert(callbacks, callback)
|
|
|
|
end
|
|
|
|
function texture_modifier_inventorycube(face_1, face_2, face_3)
|
|
|
|
return "[inventorycube{" .. string.gsub(face_1, "%^", "&")
|
|
|
|
.. "{" .. string.gsub(face_2, "%^", "&")
|
|
|
|
.. "{" .. string.gsub(face_3, "%^", "&")
|
|
|
|
end
|
|
|
|
function get_node_inventory_image(nodename)
|
|
|
|
local n = minetest.registered_nodes[nodename]
|
|
|
|
if not n then
|
|
|
|
return
|
|
|
|
end
|
|
|
|
local tiles = {}
|
|
|
|
for l, tile in pairs(n.tiles or {}) do
|
|
|
|
tiles[l] = (type(tile) == "string" and tile) or tile.name
|
|
|
|
end
|
|
|
|
local chosen_tiles = { tiles[1], tiles[3], tiles[5] }
|
|
|
|
if #chosen_tiles == 0 then
|
|
|
|
return false
|
|
|
|
end
|
|
|
|
if not chosen_tiles[2] then
|
|
|
|
chosen_tiles[2] = chosen_tiles[1]
|
|
|
|
end
|
|
|
|
if not chosen_tiles[3] then
|
|
|
|
chosen_tiles[3] = chosen_tiles[2]
|
|
|
|
end
|
|
|
|
local img = minetest.registered_items[nodename].inventory_image
|
|
|
|
if string.len(img) == 0 then
|
|
|
|
img = nil
|
|
|
|
end
|
|
|
|
return img or texture_modifier_inventorycube(chosen_tiles[1], chosen_tiles[2], chosen_tiles[3])
|
|
|
|
end
|
|
|
|
function get_color_int(color)
|
|
|
|
return color.b + (color.g*256) + (color.r*256*256)
|
|
|
|
end
|
|
|
|
function check_player_privs(playername, privtable)
|
|
|
|
local privs=minetest.get_player_privs(playername)
|
|
|
|
local missing_privs={}
|
|
|
|
local to_lose_privs={}
|
|
|
|
for priv, expected_value in pairs(privtable) do
|
|
|
|
local actual_value=privs[priv]
|
|
|
|
if expected_value then
|
|
|
|
if not actual_value then
|
|
|
|
table.insert(missing_privs, priv)
|
|
|
|
end
|
|
|
|
else
|
|
|
|
if actual_value then
|
|
|
|
table.insert(to_lose_privs, priv)
|
|
|
|
end
|
|
|
|
end
|
|
|
|
end
|
|
|
|
return missing_privs, to_lose_privs
|
|
|
|
end
|
|
|
|
|
|
|
|
minetest.register_globalstep(function(dtime)
|
|
|
|
for k, v in pairs(delta_times) do
|
|
|
|
local v=dtime+v
|
|
|
|
if v > delays[k] then
|
|
|
|
callbacks[k](v)
|
|
|
|
v=0
|
|
|
|
end
|
|
|
|
delta_times[k]=v
|
|
|
|
end
|
2020-02-09 14:58:26 +01:00
|
|
|
end)
|
|
|
|
|
|
|
|
form_listeners = {}
|
|
|
|
function register_form_listener(formname, func)
|
|
|
|
local current_listeners = form_listeners[formname] or {}
|
|
|
|
table.insert(current_listeners, func)
|
|
|
|
form_listeners[formname] = current_listeners
|
|
|
|
end
|
|
|
|
|
|
|
|
minetest.register_on_player_receive_fields(function(player, formname, fields)
|
|
|
|
local handlers = form_listeners[formname]
|
|
|
|
if handlers then
|
|
|
|
for _, handler in pairs(handlers) do
|
|
|
|
handler(player, fields)
|
|
|
|
end
|
|
|
|
end
|
2020-12-03 16:14:35 +01:00
|
|
|
end)
|
|
|
|
|
2020-12-18 10:42:03 +01:00
|
|
|
--+ Improved base64 decode removing valid padding
|
|
|
|
function decode_base64(base64)
|
|
|
|
local len = base64:len()
|
|
|
|
local padding_char = base64:sub(len, len) == "="
|
|
|
|
if padding_char then
|
|
|
|
if len % 4 ~= 0 then
|
|
|
|
return
|
|
|
|
end
|
|
|
|
if base64:sub(len-1, len-1) == "=" then
|
|
|
|
base64 = base64:sub(1, len-2)
|
|
|
|
else
|
|
|
|
base64 = base64:sub(1, len-1)
|
|
|
|
end
|
|
|
|
end
|
|
|
|
return minetest.decode_base64(base64)
|
|
|
|
end
|
|
|
|
|
2020-12-03 16:14:35 +01:00
|
|
|
liquid_level_max = 8
|
|
|
|
--+ Calculates the flow direction of a flowingliquid node
|
|
|
|
--# as returned by `minetest.get_node`
|
2020-12-17 19:06:24 +01:00
|
|
|
--> 4 corner levels from -0.5 to 0.5 as list
|
|
|
|
function get_liquid_corner_levels(pos)
|
|
|
|
local node = minetest.get_node(pos)
|
2020-12-03 16:14:35 +01:00
|
|
|
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 = {
|
|
|
|
{x = 0, z = 0},
|
|
|
|
{x = 1, z = 0},
|
|
|
|
{x = 1, z = 1},
|
|
|
|
{x = 0, z = 1}
|
|
|
|
}
|
|
|
|
for _, corner_level in pairs(corner_levels) do
|
2020-12-17 19:06:24 +01:00
|
|
|
corner_level.y = get_corner_level(corner_level.x, corner_level.z) - 0.5
|
|
|
|
corner_level.x, corner_level.z = corner_level.x - 0.5, corner_level.z - 0.5
|
2020-12-03 16:14:35 +01:00
|
|
|
end
|
|
|
|
return corner_levels
|
|
|
|
end
|
|
|
|
|
|
|
|
flowing_downwards = vector.new(0, -1, 0)
|
|
|
|
--+ Calculates the flow direction of a flowingliquid node
|
|
|
|
--# as returned by `minetest.get_node`
|
|
|
|
--> `modlib.minetest.flowing_downwards = vector.new(0, -1, 0)` if only flowing downwards
|
|
|
|
--> surface direction as `vector` else
|
2020-12-17 19:06:24 +01:00
|
|
|
function get_liquid_flow_direction(pos)
|
|
|
|
local corner_levels = get_liquid_corner_levels(pos)
|
2020-12-03 16:14:35 +01:00
|
|
|
local max_level = corner_levels[1].y
|
|
|
|
for index = 2, 4 do
|
|
|
|
local level = corner_levels[index].y
|
|
|
|
if level > max_level then
|
|
|
|
max_level = level
|
|
|
|
end
|
|
|
|
end
|
|
|
|
local dir = vector.new(0, 0, 0)
|
|
|
|
local count = 0
|
|
|
|
for max_level_index, corner_level in pairs(corner_levels) do
|
|
|
|
if corner_level.y == max_level then
|
|
|
|
for offset = 1, 3 do
|
|
|
|
local index = (max_level_index + offset - 1) % 4 + 1
|
|
|
|
local diff = vector.subtract(corner_level, corner_levels[index])
|
|
|
|
if diff.y ~= 0 then
|
|
|
|
diff.x = diff.x * diff.y
|
|
|
|
diff.z = diff.z * diff.y
|
|
|
|
if offset == 3 then
|
|
|
|
diff = vector.divide(diff, math.sqrt(2))
|
|
|
|
end
|
|
|
|
dir = vector.add(dir, diff)
|
|
|
|
count = count + 1
|
|
|
|
end
|
|
|
|
end
|
|
|
|
end
|
|
|
|
end
|
|
|
|
if count ~= 0 then
|
|
|
|
dir = vector.divide(dir, count)
|
|
|
|
end
|
|
|
|
if vector.equals(dir, vector.new(0, 0, 0)) then
|
|
|
|
if node.param2 % 32 > 7 then
|
|
|
|
return flowing_downwards
|
|
|
|
end
|
|
|
|
end
|
|
|
|
return dir
|
|
|
|
end
|
2020-12-17 19:10:56 +01:00
|
|
|
|
|
|
|
--+ Möller-Trumbore
|
|
|
|
function ray_triangle_intersection(origin, direction, triangle)
|
|
|
|
local point_1, point_2, point_3 = unpack(triangle)
|
|
|
|
local edge_1, edge_2 = vector.subtract(point_2, point_1), vector.subtract(point_3, point_1)
|
|
|
|
local h = vector.cross(direction, edge_2)
|
|
|
|
local a = vector.dot(edge_1, h)
|
|
|
|
if math.abs(a) < 1e-9 then
|
|
|
|
return
|
|
|
|
end
|
|
|
|
local f = 1 / a
|
|
|
|
local diff = vector.subtract(origin, point_1)
|
|
|
|
local u = f * vector.dot(diff, h)
|
|
|
|
if u < 0 or u > 1 then
|
|
|
|
return
|
|
|
|
end
|
|
|
|
local q = vector.cross(diff, edge_1)
|
|
|
|
local v = f * vector.dot(direction, q)
|
|
|
|
if v < 0 or u + v > 1 then
|
|
|
|
return
|
|
|
|
end
|
|
|
|
local pos_on_line = f * vector.dot(edge_2, q);
|
|
|
|
if pos_on_line >= 0 then
|
|
|
|
return pos_on_line
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
function triangle_normal(triangle)
|
|
|
|
local point_1, point_2, point_3 = unpack(triangle)
|
|
|
|
local edge_1, edge_2 = vector.subtract(point_2, point_1), vector.subtract(point_3, point_1)
|
|
|
|
return vector.normalize{
|
|
|
|
x = edge_1.y * edge_2.z - edge_1.z * edge_2.y,
|
|
|
|
y = edge_1.z * edge_2.x - edge_1.x * edge_2.z,
|
|
|
|
z = edge_1.x * edge_2.y - edge_1.y * edge_2.x
|
|
|
|
}
|
|
|
|
end
|
|
|
|
|
|
|
|
--+ Raycast wrapper with proper flowingliquid intersections
|
|
|
|
function raycast(pos1, pos2, objects, liquids)
|
|
|
|
local raycast = minetest.raycast(pos1, pos2, objects, liquids)
|
|
|
|
if not liquids then
|
|
|
|
return raycast
|
|
|
|
end
|
|
|
|
local direction = vector.direction(pos1, pos2)
|
|
|
|
local length = vector.distance(pos1, pos2)
|
|
|
|
local function next()
|
|
|
|
for pointed_thing in raycast do
|
|
|
|
if pointed_thing.type ~= "node" then
|
|
|
|
return pointed_thing
|
|
|
|
end
|
|
|
|
local pos = pointed_thing.under
|
|
|
|
local node = minetest.get_node(pos)
|
|
|
|
local def = minetest.registered_nodes[node.name]
|
|
|
|
if not (def and def.drawtype == "flowingliquid") then return pointed_thing end
|
|
|
|
local corner_levels = get_liquid_corner_levels(pos)
|
|
|
|
local full_corner_levels = true
|
|
|
|
for _, corner_level in pairs(corner_levels) do
|
|
|
|
if corner_level.y < 0.5 then
|
|
|
|
full_corner_levels = false
|
|
|
|
break
|
|
|
|
end
|
|
|
|
end
|
|
|
|
if full_corner_levels then
|
|
|
|
return pointed_thing
|
|
|
|
end
|
|
|
|
-- origin = pos
|
|
|
|
local relative = vector.subtract(pos1, pos)
|
|
|
|
local inside = true
|
|
|
|
for _, prop in pairs(relative) do
|
|
|
|
if prop <= -0.5 or prop >= 0.5 then
|
|
|
|
inside = false
|
|
|
|
break
|
|
|
|
end
|
|
|
|
end
|
|
|
|
local function level(x, z)
|
|
|
|
local function distance_squared(corner)
|
|
|
|
return (x - corner.x) ^ 2 + (z - corner.z) ^ 2
|
|
|
|
end
|
|
|
|
local irrelevant_corner, distance = 1, distance_squared(corner_levels[1])
|
|
|
|
for index = 2, 4 do
|
|
|
|
local other_distance = distance_squared(corner_levels[index])
|
|
|
|
if other_distance > distance then
|
|
|
|
irrelevant_corner, distance = index, other_distance
|
|
|
|
end
|
|
|
|
end
|
|
|
|
local function corner(off)
|
|
|
|
return corner_levels[((irrelevant_corner + off) % 4) + 1]
|
|
|
|
end
|
|
|
|
local base = corner(2)
|
|
|
|
local edge_1, edge_2 = vector.subtract(corner(1), base), vector.subtract(corner(3), base)
|
|
|
|
assert(math.abs(edge_1.x + edge_1.z) + math.abs(edge_2.x + edge_2.z) == 2)
|
|
|
|
if edge_1.x == 0 then
|
|
|
|
edge_1, edge_2 = edge_2, edge_1
|
|
|
|
end
|
|
|
|
local level = base.y + (edge_1.y * ((x - base.x) / edge_1.x)) + (edge_2.y * ((z - base.z) / edge_2.z))
|
|
|
|
assert(level >= -0.5 and level <= 0.5)
|
|
|
|
return level
|
|
|
|
end
|
|
|
|
inside = inside and (relative.y < level(relative.x, relative.z))
|
|
|
|
if inside then
|
|
|
|
-- pos1 is inside the liquid node
|
|
|
|
pointed_thing.intersection_point = pos1
|
|
|
|
pointed_thing.intersection_normal = vector.new(0, 0, 0)
|
|
|
|
return pointed_thing
|
|
|
|
end
|
|
|
|
local function intersection_normal(axis, dir)
|
|
|
|
return {x = 0, y = 0, z = 0, [axis] = dir}
|
|
|
|
end
|
|
|
|
local function plane(axis, dir)
|
|
|
|
local offset = dir * 0.5
|
|
|
|
local diff_axis = (relative[axis] - offset) / -direction[axis]
|
|
|
|
local intersection_point = {}
|
|
|
|
for plane_axis in pairs{x = true, y = true, z = true, [axis] = nil} do
|
|
|
|
local value = direction[plane_axis] * diff_axis + relative[plane_axis]
|
|
|
|
if value < -0.5 or value > 0.5 then
|
|
|
|
return
|
|
|
|
end
|
|
|
|
intersection_point[plane_axis] = value
|
|
|
|
end
|
|
|
|
intersection_point[axis] = offset
|
|
|
|
return intersection_point
|
|
|
|
end
|
|
|
|
if direction.y > 0 then
|
|
|
|
local intersection_point = plane("y", -1)
|
|
|
|
if intersection_point then
|
|
|
|
pointed_thing.intersection_point = vector.add(intersection_point, pos)
|
|
|
|
pointed_thing.intersection_normal = intersection_normal("y", -1)
|
|
|
|
return pointed_thing
|
|
|
|
end
|
|
|
|
end
|
|
|
|
for coord, other in pairs{x = "z", z = "x"} do
|
|
|
|
if direction[coord] ~= 0 then
|
|
|
|
local dir = direction[coord] > 0 and -1 or 1
|
|
|
|
local intersection_point = plane(coord, dir)
|
|
|
|
if intersection_point then
|
|
|
|
local height = 0
|
|
|
|
for _, corner in pairs(corner_levels) do
|
|
|
|
if corner[coord] == dir * 0.5 then
|
|
|
|
height = height + (math.abs(intersection_point[other] + corner[other])) * corner.y
|
|
|
|
end
|
|
|
|
end
|
|
|
|
if intersection_point.y <= height then
|
|
|
|
pointed_thing.intersection_point = vector.add(intersection_point, pos)
|
|
|
|
pointed_thing.intersection_normal = intersection_normal(coord, dir)
|
|
|
|
return pointed_thing
|
|
|
|
end
|
|
|
|
end
|
|
|
|
end
|
|
|
|
end
|
|
|
|
for _, triangle in pairs{
|
|
|
|
{corner_levels[1], corner_levels[2], corner_levels[3]},
|
|
|
|
{corner_levels[1], corner_levels[3], corner_levels[4]}
|
|
|
|
} do
|
|
|
|
local pos_on_ray = ray_triangle_intersection(relative, direction, triangle)
|
|
|
|
if pos_on_ray and pos_on_ray <= length then
|
|
|
|
pointed_thing.intersection_point = vector.add(pos1, vector.multiply(direction, pos_on_ray))
|
|
|
|
pointed_thing.intersection_normal = vector.multiply(triangle_normal(triangle), -1)
|
|
|
|
return pointed_thing
|
|
|
|
end
|
|
|
|
end
|
|
|
|
end
|
|
|
|
end
|
|
|
|
return setmetatable({next = next}, {__call = next})
|
|
|
|
end
|