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") -- 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 = {} 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. -- 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 rotate.rotate_node(pos, node, state.facedir) return true 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, ...) 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 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.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 return state 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)