From 04ca1950d70035417c6083bb02101f0f66918a56 Mon Sep 17 00:00:00 2001 From: copygirl Date: Fri, 20 Oct 2023 00:36:02 +0200 Subject: [PATCH] Redo file structure, fix unpinnable doors - Use global to hold sub-modules - Move state calculation to state.lua - Do manual overriding of on_rightclick functions - Call default right-click impl when holding pin on door --- hud.lua | 28 ++++---- init.lua | 183 +++++++++++++++++++++++++++------------------------ registry.lua | 57 +++------------- rotate.lua | 34 +++++----- state.lua | 83 +++++++++++++++++++++++ utility.lua | 18 +++-- 6 files changed, 226 insertions(+), 177 deletions(-) create mode 100755 state.lua diff --git a/hud.lua b/hud.lua index 200cff8..7ca00ae 100644 --- a/hud.lua +++ b/hud.lua @@ -6,22 +6,23 @@ local LABEL_ROTATION_HINT = "rotation hint" local TEX_ROTATE_FACE = "nc_extended_rotating_hud_rotate_face.png" local TEX_ROTATE_EDGE = "nc_extended_rotating_hud_rotate_edge.png" + local hud = {} -local function crosshair_hud_element(texture) - return { - label = LABEL_ROTATION_HINT, - hud_elem_type = "image", - text = texture, - position = { x = 0.5, y = 0.5 }, - offset = { x = 0, y = 0 }, - alignment = { x = 0, y = 0 }, - scale = { x = 1, y = 1 }, - quick = true - } -end +function hud.update_player_hud(player, state) + local function crosshair_hud_element(texture) + return { + label = LABEL_ROTATION_HINT, + hud_elem_type = "image", + text = texture, + position = { x = 0.5, y = 0.5 }, + offset = { x = 0, y = 0 }, + alignment = { x = 0, y = 0 }, + scale = { x = 1, y = 1 }, + quick = true + } + end -local function update_player_hud(player, state) local mode = state and state.mode if mode == "face" then local texture = TEX_ROTATE_FACE @@ -32,6 +33,5 @@ local function update_player_hud(player, state) nodecore.hud_set(player, { label = LABEL_ROTATION_HINT, ttl = 0 }) end end -hud.update_player_hud = update_player_hud return hud diff --git a/init.lua b/init.lua index 97563aa..2038823 100755 --- a/init.lua +++ b/init.lua @@ -1,104 +1,115 @@ -local minetest, vector, nodecore, include - = minetest, vector, nodecore, include -local math_round = math.round - -local hud = include("hud") -local rotate = include("rotate") -local utility = include("utility") -local registry = include("registry") - +local ipairs, ItemStack, minetest, vector, include, nodecore + = ipairs, ItemStack, minetest, vector, include, nodecore + +rawset(_G, "nc_extended_rotating", {}) +nc_extended_rotating.hud = include("hud") +nc_extended_rotating.registry = include("registry") +nc_extended_rotating.rotate = include("rotate") +nc_extended_rotating.utility = include("utility") -- Depends on `rotate`. +nc_extended_rotating.state = include("state") -- Depends on `registry`, `rotate` and `utility`. + +local update_player_hud = nc_extended_rotating.hud.update_player_hud +local is_rotatable = nc_extended_rotating.registry.is_rotatable +local register_rotatable = nc_extended_rotating.registry.register_rotatable; +local rotate_node = nc_extended_rotating.rotate.rotate_node +local update_rotating_state = nc_extended_rotating.state.update_rotating_state +local get_rotating_state = nc_extended_rotating.state.get_rotating_state + +-- TODO: Fix HUD showing rotation hint when we wouldn't / can't rotate. -- TODO: Add crosshair indicators for rotating around edges. -- TODO: Add some more comments. -- TODO: Add particles to preview rotation? --- Distance at which we want to rotate by "pushing" on an edge. -local EDGE_DISTANCE = 2.5 / 16 -- texels (at 16² texture resolution) - --- Contains a per-player state that holds information, created by a raycast --- done in `playerstep`, about the node this player might rotate. This is used --- to update the their HUD and to decide what to do when a rightclick occurs. -local rotating_state = {} +nodecore.register_playerstep({ + label = "nc_extended_rotating:update", + action = function(player, data) + local state = update_rotating_state(player, data) + update_player_hud(player, state) + end, +}) +-- Register rotatable nodes from NodeCore. +do + local function nodecore_filtered_lookup(eq_func) + local lookup = {} + for i = 0, 23 do + local facedir = nodecore.facedirs[i] + for j = 0, #lookup - 1 do + local other = nodecore.facedirs[lookup[j]] + if eq_func(facedir, other) then lookup[i] = j; break end + end + lookup[i] = lookup[i] or i + end + return lookup + end -local function handle_rotatable_rightclick(pos, node, clicker) - local state = rotating_state[clicker:get_player_name()] - if not state then return false end -- Not looking at anything rotatable. + local LENS_FILTERED_LOOKUP = nodecore_filtered_lookup( + function(a, b) return vector.equals(a.f, b.f) end) + local PRISM_FILTERED_LOOKUP = nodecore_filtered_lookup( + function(a, b) return vector.equals(a.f, b.r) and vector.equals(a.r, b.f) end) + local PANEL_FILTERED_LOOKUP = nodecore_filtered_lookup( + function(a, b) return vector.equals(a.f, b.r) and vector.equals(a.r, b.f) end) - -- Make sure we're still the same node that we raycasted in `playerstep`. - if not vector.equals(pos, state.pos) then return true end - if node.name ~= state.node.name or node.param2 ~= state.node.param2 then return true end - -- Only continue if the node can actually be sucessfully rotated. - if not state.success then return true end + for _, lens_state in ipairs({ "", "_on", "_glow", "_glow_start" }) do + register_rotatable("nc_optics:lens" .. lens_state, LENS_FILTERED_LOOKUP) end + for _, prism_state in ipairs({ "", "_on", "_gated" }) do + register_rotatable("nc_optics:prism" .. prism_state, PRISM_FILTERED_LOOKUP) end - rotate.rotate_node(pos, node, state.facedir) - return true + register_rotatable("nc_doors:panel_plank" , PANEL_FILTERED_LOOKUP) + register_rotatable("nc_doors:panel_cobble", PANEL_FILTERED_LOOKUP) end -registry.custom_on_rightclick = handle_rotatable_rightclick --- Override `nc_scaling`'s default empty hand right-click behavior so we can use it --- to rotate things when holding sneak, which doesn't trigger a node's `on_rightclick`. -local default_on_place = minetest.registered_items[""].on_place -minetest.registered_items[""].on_place = function(item_stack, placer, pointed_thing, ...) - -- Player must sneak in order for this to run. Non-sneak is handled by node's `on_rightclick`. - if pointed_thing.type == "node" and minetest.is_player(placer) and placer:get_player_control().sneak then - local pos = pointed_thing.under - local node = minetest.get_node(pos) - if handle_rotatable_rightclick(pos, node, placer) then return end - end - default_on_place(item_stack, placer, pointed_thing, ...) +local function handle_rightclick(pos, node, clicker) + local state = get_rotating_state(clicker, pos, node) + if (not state) or (not state.success) then return end + rotate_node(pos, node, state.facedir) end - --- Calculates the state for the specified `player` and player `data`. --- This state contains information about how the player would rotate a block. -local function calculate_rotating_state(player, data) - local state = {} - - local pointed_thing = data.raycast() - if (not pointed_thing) or pointed_thing.type ~= "node" then return nil end - - state.pos = pointed_thing.under - state.node = minetest.get_node(state.pos) - if not registry.is_rotatable(state.node) then return nil end - - if vector.equals(pointed_thing.above, pointed_thing.under) then return nil end - state.face = pointed_thing.above - pointed_thing.under - - -- When player is sneaking, must be empty-handed for rotating to work. - local is_sneaking = player:get_player_control().sneak - if is_sneaking and (not player:get_wielded_item():is_empty()) then return nil end - - local degrees = 90 - local r = utility.rotation_vector_from_lookat(state.node, pointed_thing, EDGE_DISTANCE) - state.axis = r - - local num = math_round(r.x * r.x + r.y * r.y + r.z * r.z) -- Squared length. - if num == 1 then state.mode = "face" - elseif num == 2 then state.mode = "edge"; state.axis = state.face:cross(r) - elseif num == 3 then state.mode = "mirror"; degrees = 120 +-- Replace `on_rightclick` of rotatable nodes from NodeCore. +do + local function replace_optics_on_rightclick(name) + local def = minetest.registered_nodes[name] + def.on_rightclick = handle_rightclick end - -- Sneaking causes the direction of the rotation to be inverted. - if is_sneaking then degrees = -degrees end - state.invert = is_sneaking + -- Panels can't have their `on_rightclick` overridden completely. + -- We need to call the default implementation when holding a "pin". + local function replace_panel_on_rightclick(name, pin) + local def = minetest.registered_nodes[name] + local default_rightclick = def.on_rightclick + def.on_rightclick = function(pos, node, clicker, item_stack, ...) + if nodecore.protection_test(pos, clicker) or ItemStack(item_stack):get_name() == pin + then return default_rightclick(pos, node, clicker, item_stack, ...) + else return handle_rightclick(pos, node, clicker) + end + end + end - state.facedir = rotate.rotate_facedir(state.node.param2, state.axis, -degrees) - state.facedir = registry.fix_rotatable_facedir(state.node, state.facedir) - state.success = state.facedir and state.facedir ~= state.node.param2 + for _, lens_state in ipairs({ "", "_on", "_glow", "_glow_start" }) do + replace_optics_on_rightclick("nc_optics:lens" .. lens_state) end + for _, lens_state in ipairs({ "", "_on", "_gated" }) do + replace_optics_on_rightclick("nc_optics:prism" .. lens_state) end - return state + replace_panel_on_rightclick("nc_doors:panel_plank" , "nc_woodwork:staff") + replace_panel_on_rightclick("nc_doors:panel_cobble", "nc_lode:rod_tempered") end -nodecore.register_playerstep({ - label = "extended rotating update", - action = function(player, data) - local name = player:get_player_name() - rotating_state[name] = calculate_rotating_state(player, data) - hud.update_player_hud(player, rotating_state[name]) - end, -}) - -minetest.register_on_leaveplayer(function(player) - local name = player:get_player_name() - rotating_state[name] = nil -end) +-- Override `nc_scaling`'s default empty hand right-click behavior so we can use it +-- to rotate things when holding sneak, which doesn't trigger a node's `on_rightclick`. +local default_on_place = minetest.registered_items[""].on_place +minetest.registered_items[""].on_place = function(item_stack, placer, pointed_thing, ...) + if pointed_thing.type == "node" then + -- Player must sneak in order for this to run. + -- Non-sneak is handled by node's `on_rightclick`. + if minetest.is_player(placer) and placer:get_player_control().sneak then + local pos = pointed_thing.under + local node = minetest.get_node(pos) + if is_rotatable(node) then + handle_rightclick(pos, node, placer) + return -- Skip default behavior. + end + end + end + -- Call the default function, so we can still get the "scaling" functionality. + default_on_place(item_stack, placer, pointed_thing, ...) +end diff --git a/registry.lua b/registry.lua index b015812..e5df75e 100644 --- a/registry.lua +++ b/registry.lua @@ -1,73 +1,34 @@ -local minetest, nodecore - = minetest, nodecore +local minetest + = minetest -local registry = {} +-- Table of nodes that can be rotated by the mod. local registered_rotatables = {} --- Registered rotatable nodes will call this function when their `on_rightclick` --- is triggered instead of their default implementation. Can be overwritten. -registry.custom_on_rightclick = function(pos, node, clicker, item_stack, pointed_thing) end -local function register_rotatable(name, facedir_lookup) +local registry = {} + +function registry.register_rotatable(name, facedir_lookup) local def = minetest.registered_nodes[name] if not def then error("Unknown node '" .. name .. "'") end if def.paramtype2 ~= "facedir" then error("Node '" .. name .. "' must be 'facedir'") end - def.on_rightclick = function(...) registry.custom_on_rightclick(...) end registered_rotatables[name] = { lookup = facedir_lookup } end -registry.register_rotatable = register_rotatable -- Returns whether the specified `node` is rotatable by this mod. -local function is_rotatable(node) - local name = node and node.name or "" - return not not registered_rotatables[name] +function registry.is_rotatable(node) + return not not registered_rotatables[node.name] end -registry.is_rotatable = is_rotatable -- Fixes facedir for the specified `node` when rotated to `facedir`. -- * Returns `nil` if the node can't rotate this way. -- * Returns `facedir` when the node can rotate this way. -- * Returns another facedir when the node should rotate another equivalent way. -local function fix_rotatable_facedir(node, facedir) +function registry.fix_rotatable_facedir(node, facedir) local name = node and node.name or "" local entry = registered_rotatables[name] if not entry then return nil end if not entry.lookup then return facedir end return entry.lookup[facedir] end -registry.fix_rotatable_facedir = fix_rotatable_facedir - - --------------------------------------------- --- Register rotatable nodes from NodeCore -- --------------------------------------------- - -local function nodecore_filtered_lookup(eq_func) - local lookup = {} - for i = 0, 23 do - local facedir = nodecore.facedirs[i] - for j = 0, #lookup - 1 do - local other = nodecore.facedirs[lookup[j]] - if eq_func(facedir, other) then lookup[i] = j; break end - end - lookup[i] = lookup[i] or i - end - return lookup -end - -local LENS_FILTERED_LOOKUP = nodecore_filtered_lookup( - function(a, b) return vector.equals(a.f, b.f) end) -local PRISM_FILTERED_LOOKUP = nodecore_filtered_lookup( - function(a, b) return vector.equals(a.f, b.r) and vector.equals(a.r, b.f) end) -local PANEL_FILTERED_LOOKUP = nodecore_filtered_lookup( - function(a, b) return vector.equals(a.f, b.r) and vector.equals(a.r, b.f) end) - -for _, lens_state in ipairs({ "", "_on", "_glow", "_glow_start" }) do - register_rotatable("nc_optics:lens" .. lens_state, LENS_FILTERED_LOOKUP) end -for _, prism_state in ipairs({ "", "_on", "_gated" }) do - register_rotatable("nc_optics:prism" .. prism_state, PRISM_FILTERED_LOOKUP) end - -register_rotatable("nc_doors:panel_plank" , PANEL_FILTERED_LOOKUP) -register_rotatable("nc_doors:panel_cobble", PANEL_FILTERED_LOOKUP) return registry diff --git a/rotate.lua b/rotate.lua index 5345894..26bb8c6 100644 --- a/rotate.lua +++ b/rotate.lua @@ -5,8 +5,6 @@ local math_min, math_max, math_floor, math_rad local minetest, vector = minetest, vector -local rotate = {} - -- Axis lookup table based on how Minetest's `facedir` operates. local AXIS_LOOKUP = { vector.new( 0, 1, 0), -- +Y @@ -50,24 +48,12 @@ for up_index, up in ipairs(AXIS_LOOKUP) do end end --- Rotates (or "spins") the specified `node` to face `facedir`, --- emulating the behavior of NodeCore's spin functionality. -local function rotate_node(pos, node, facedir) - local def = minetest.registered_nodes[node.name] - if (not def) or def.paramtype2 ~= "facedir" then error("Node's paramtype2 must be 'facedir'") end - minetest.swap_node(pos, nodecore.underride({ param2 = facedir }, node)) - nodecore.node_sound(pos, "place") - if def.on_spin then def.on_spin(pos, node) end -end -rotate.rotate_node = rotate_node - -- Returns the `up` and `back` vectors that make up the specified `facedir`. local function vectors_from_facedir(facedir) local up = AXIS_LOOKUP[1 + math_floor(facedir / 4)] local back = minetest.facedir_to_dir(facedir) return up, back end -rotate.vectors_from_facedir = vectors_from_facedir -- Returns a `facedir` constructed from the specified `up` and `back` vectors. local function facedir_from_vectors(up, back) @@ -75,10 +61,22 @@ local function facedir_from_vectors(up, back) local back_index = axis_vector_to_index(back) return FACEDIR_LOOKUP[up_index][back_index] end -rotate.facedir_from_vectors = facedir_from_vectors + + +local rotate = {} + +-- Rotates (or "spins") the specified `node` to face `facedir`, +-- emulating the behavior of NodeCore's spin functionality. +function rotate.rotate_node(pos, node, facedir) + local def = minetest.registered_nodes[node.name] + if (not def) or def.paramtype2 ~= "facedir" then error("Node's paramtype2 must be 'facedir'") end + minetest.swap_node(pos, nodecore.underride({ param2 = facedir }, node)) + nodecore.node_sound(pos, "place") + if def.on_spin then def.on_spin(pos, node) end +end -- Returns the specified `facedir` rotated around `vec` by `degrees` counter-clickwise. -local function rotate_facedir(facedir, vec, degrees) +function rotate.rotate_facedir(facedir, vec, degrees) -- NOTE: Removed the axis requirement so we can use this to rotate around corners. -- However, since we `round` the result vectors this might ignore errors. -- if degrees % 90 ~= 0 then error("degrees must be divisible by 90") end @@ -88,11 +86,10 @@ local function rotate_facedir(facedir, vec, degrees) back = back:rotate_around_axis(vec, math_rad(degrees)):round() return facedir_from_vectors(up, back) end -rotate.rotate_facedir = rotate_facedir -- Rotates the specified default orientation `{ min, max }` box to -- one matching Minetest's rotation algorithm pointing to `facedir`. -local function rotate_box_by_facedir(box, facedir) +function rotate.rotate_box_by_facedir(box, facedir) if facedir == 0 then return end local axis_index = math_floor(facedir / 4) @@ -115,6 +112,5 @@ local function rotate_box_by_facedir(box, facedir) box.min.y, box.max.y = math_min(box.min.y, box.max.y), math_max(box.min.y, box.max.y) box.min.z, box.max.z = math_min(box.min.z, box.max.z), math_max(box.min.z, box.max.z) end -rotate.rotate_box_by_facedir = rotate_box_by_facedir return rotate diff --git a/state.lua b/state.lua new file mode 100755 index 0000000..c093013 --- /dev/null +++ b/state.lua @@ -0,0 +1,83 @@ +local math_round, minetest, vector + = math.round, minetest, vector + +local fix_rotatable_facedir = nc_extended_rotating.registry.fix_rotatable_facedir; +local is_rotatable = nc_extended_rotating.registry.is_rotatable; +local rotate_facedir = nc_extended_rotating.rotate.rotate_facedir; +local rotation_vector_from_lookat = nc_extended_rotating.utility.rotation_vector_from_lookat; + +-- Distance at which we want to rotate by "pushing" on an edge. +local EDGE_DISTANCE = 2.5 / 16 -- texels (at 16² texture resolution) + + +-- Contains a per-player state that holds information, created by a raycast +-- done in `playerstep`, about the node this player might rotate. This is used +-- to update the their HUD and to decide what to do when a rightclick occurs. +local rotating_state = {} + +-- Calculates the state for the specified `player` and player `data`. +-- This state contains information about how the player would rotate a block. +local function calculate_rotating_state(player, data) + local state = {} + + local pointed_thing = data.raycast() + if (not pointed_thing) or pointed_thing.type ~= "node" then return nil end + + state.pos = pointed_thing.under + state.node = minetest.get_node(state.pos) + if not is_rotatable(state.node) then return nil end + + if vector.equals(pointed_thing.above, pointed_thing.under) then return nil end + state.face = pointed_thing.above - pointed_thing.under + + -- When player is sneaking, must be empty-handed for rotating to work. + local is_sneaking = player:get_player_control().sneak + if is_sneaking and (not player:get_wielded_item():is_empty()) then return nil end + + local degrees = 90 + local r = rotation_vector_from_lookat(state.node, pointed_thing, EDGE_DISTANCE) + state.axis = r + + local num = math_round(r.x * r.x + r.y * r.y + r.z * r.z) -- Squared length. + if num == 1 then state.mode = "face" + elseif num == 2 then state.mode = "edge"; state.axis = state.face:cross(r) + elseif num == 3 then state.mode = "mirror"; degrees = 120 + end + + -- Sneaking causes the direction of the rotation to be inverted. + if is_sneaking then degrees = -degrees end + state.invert = is_sneaking + + state.facedir = rotate_facedir(state.node.param2, state.axis, -degrees) + state.facedir = fix_rotatable_facedir(state.node, state.facedir) + state.success = state.facedir and state.facedir ~= state.node.param2 + + return state +end + +minetest.register_on_leaveplayer(function(player) + local name = player:get_player_name() + rotating_state[name] = nil +end) + + +local state = {} + +function state.update_rotating_state(player, data) + local rot_state = calculate_rotating_state(player, data) + rotating_state[player:get_player_name()] = rot_state + return rot_state +end + +function state.get_rotating_state(player, pos, node) + if not minetest.is_player(player) then return nil end + local rot_state = rotating_state[player:get_player_name()] + if not rot_state then return nil end + + if not vector.equals(pos, rot_state.pos) then return nil end + if node.name ~= rot_state.node.name or node.param2 ~= rot_state.node.param2 then return nil end + + return rot_state +end + +return state diff --git a/utility.lua b/utility.lua index 9949081..f42da82 100644 --- a/utility.lua +++ b/utility.lua @@ -1,12 +1,8 @@ -local math_abs, math_sign - = math.abs, math.sign -local minetest, vector, include - = minetest, vector, include +local minetest, vector, math_abs, math_sign + = minetest, vector, math.abs, math.sign -local rotate = include("rotate") - -local utility = {} +local rotate_box_by_facedir = nc_extended_rotating.rotate.rotate_box_by_facedir -- Default selection boxes for a node that doesn't have one them explicitly. local DEFAULT_SELECTION_BOX = { min = vector.new(-0.5, -0.5, -0.5), @@ -25,15 +21,18 @@ local function get_node_active_selection_box(node) box = { min = vector.new(box[1], box[2], box[3]), max = vector.new(box[4], box[5], box[6]) } -- Rotate the box to face `facedir`. - rotate.rotate_box_by_facedir(box, node.param2) + rotate_box_by_facedir(box, node.param2) return box end + +local utility = {} + -- Calculates the rotation vector from where a player is looking at on this node. -- * If looking near an edge, the vector points in the direction of that edge. -- * If looking near a corner, the vector similarly points in that direction. -- * Otherwise, vector simply points away from the face. -local function rotation_vector_from_lookat(node, pointed_thing, edge_distance) +function utility.rotation_vector_from_lookat(node, pointed_thing, edge_distance) local box = get_node_active_selection_box(node) local center = (box.min + box.max) / 2 @@ -45,6 +44,5 @@ local function rotation_vector_from_lookat(node, pointed_thing, edge_distance) return point:combine(bounds, function(p, b) return b - math_abs(p) <= edge_distance and math_sign(p) or 0 end) end -utility.rotation_vector_from_lookat = rotation_vector_from_lookat return utility