X-Git-Url: https://git.lizzy.rs/?a=blobdiff_plain;f=api.lua;h=2a73977145629667fdf6e9f5cfd7427fd425fe53;hb=e92177b83e8c987082810c79b2472a48e91e4c3e;hp=80e545b6d243af42901c942d311f2d2685913bc5;hpb=4ff54c9a4db6ff05da4b7eb74814a9eeb8ce3d59;p=signs_lib.git diff --git a/api.lua b/api.lua index 80e545b..2a73977 100644 --- a/api.lua +++ b/api.lua @@ -6,20 +6,34 @@ signs_lib.lbm_restore_nodes = {} signs_lib.old_fenceposts = {} signs_lib.old_fenceposts_replacement_signs = {} signs_lib.old_fenceposts_with_signs = {} -signs_lib.allowed_poles = {} -- Settings used for a standard wood or steel wall sign signs_lib.standard_lines = 6 -signs_lib.standard_hscale = 1.7 -signs_lib.standard_vscale = 1.75 +signs_lib.standard_hscale = 1 +signs_lib.standard_vscale = 1 signs_lib.standard_lspace = 1 signs_lib.standard_fsize = 15 -signs_lib.standard_xoffs = 5 -signs_lib.standard_yoffs = 38 -signs_lib.standard_cpl = 25 +signs_lib.standard_xoffs = 4 +signs_lib.standard_yoffs = 0 +signs_lib.standard_cpl = 35 -signs_lib.standard_wood_groups = {choppy = 2, flammable = 2, oddly_breakable_by_hand = 3} -signs_lib.standard_steel_groups = {cracky = 2, oddly_breakable_by_hand = 3} +signs_lib.standard_wood_groups = table.copy(minetest.registered_items["default:sign_wall_wood"].groups) +signs_lib.standard_wood_groups.sign = 1 +signs_lib.standard_wood_groups.attached_node = nil + +signs_lib.standard_steel_groups = table.copy(minetest.registered_items["default:sign_wall_steel"].groups) +signs_lib.standard_steel_groups.sign = 1 +signs_lib.standard_steel_groups.attached_node = nil + +signs_lib.standard_wood_sign_sounds = table.copy(minetest.registered_items["default:sign_wall_wood"].sounds) +signs_lib.standard_steel_sign_sounds = table.copy(minetest.registered_items["default:sign_wall_steel"].sounds) + +signs_lib.default_text_scale = {x=10, y=10} + +signs_lib.old_widefont_signs = {} + +signs_lib.block_list = {} +signs_lib.totalblocks = 0 signs_lib.standard_yaw = { 0, @@ -37,15 +51,6 @@ signs_lib.wallmounted_yaw = { math.pi, } -local wall_dir_change = { - [0] = 2, - 2, - 5, - 4, - 2, - 3, -} - signs_lib.fdir_to_back = { { 0, -1 }, { -1, 0 }, @@ -62,37 +67,252 @@ signs_lib.wall_fdir_to_back = { { 1, 0 }, } +signs_lib.fdir_flip_to_back = { + [0] = { 0, 2 }, + [1] = { 2, 0 }, + [2] = { 0, -2 }, + [3] = { -2, 0 } +} + +signs_lib.wall_fdir_flip_to_back = { + [2] = { 2, 0 }, + [3] = { -2, 0 }, + [4] = { 0, 2 }, + [5] = { 0, -2 }, +} + +signs_lib.fdir_to_back_left = { + [0] = { -1, 1 }, + [1] = { 1, 1 }, + [2] = { 1, -1 }, + [3] = { -1, -1 } +} + +signs_lib.wall_fdir_to_back_left = { + [2] = { 1, 1 }, + [3] = { -1, -1 }, + [4] = { -1, 1 }, + [5] = { 1, -1 } +} + +signs_lib.rotate_walldir = { + [0] = 4, + [1] = 0, + [2] = 5, + [3] = 1, + [4] = 2, + [5] = 3 +} + +signs_lib.rotate_walldir_simple = { + [0] = 4, + [1] = 4, + [2] = 5, + [3] = 4, + [4] = 2, + [5] = 3 +} + +signs_lib.rotate_facedir = { + [0] = 1, + [1] = 2, + [2] = 3, + [3] = 4, + [4] = 6, + [5] = 6, + [6] = 0 +} + +signs_lib.rotate_facedir_simple = { + [0] = 1, + [1] = 2, + [2] = 3, + [3] = 0, + [4] = 0, + [5] = 0 +} + +signs_lib.flip_facedir = { + [0] = 2, + [1] = 3, + [2] = 0, + [3] = 1, + [4] = 6, + [5] = 4, + [6] = 4 +} + +signs_lib.flip_walldir = { + [0] = 1, + [1] = 0, + [2] = 3, + [3] = 2, + [4] = 5, + [5] = 4 +} + -- Initialize character texture cache local ctexcache = {} -signs_lib.wallmounted_rotate = function(pos, node, user, mode) - if mode ~= screwdriver.ROTATE_FACE then return false end - minetest.swap_node(pos, { name = node.name, param2 = wall_dir_change[node.param2 % 6] }) - for _, v in ipairs(minetest.get_objects_inside_radius(pos, 0.5)) do - local e = v:get_luaentity() - if e and e.name == "signs_lib:text" then - v:remove() +-- entity handling + +minetest.register_entity("signs_lib:text", { + collisionbox = { 0, 0, 0, 0, 0, 0 }, + visual = "mesh", + mesh = "signs_lib_standard_wall_sign_entity.obj", + textures = {}, + static_save = false, + backface_culling = false +}) + +function signs_lib.delete_objects(pos) + local objects = minetest.get_objects_inside_radius(pos, 0.5) + for _, v in ipairs(objects) do + if v then + local e = v:get_luaentity() + if e and string.match(e.name, "sign.*text") then + v:remove() + end end end - signs_lib.update_sign(pos) - return true end -signs_lib.facedir_rotate = function(pos, node, user, mode) - if mode ~= screwdriver.ROTATE_FACE or not signs_lib.can_modify(pos, user) then return end - newparam2 = ((node.param2 % 6 ) == 0) and 1 or 0 - minetest.swap_node(pos, { name = node.name, param2 = newparam2 }) - for _, v in ipairs(minetest.get_objects_inside_radius(pos, 0.5)) do - local e = v:get_luaentity() - if e and e.name == "signs_lib:text" then - v:remove() +function signs_lib.spawn_entity(pos, texture) + local node = minetest.get_node(pos) + local def = minetest.registered_items[node.name] + if not def or not def.entity_info then return end + + local text_scale = (node and node.text_scale) or signs_lib.default_text_scale + local objects = minetest.get_objects_inside_radius(pos, 0.5) + local obj + + if #objects > 0 then + for _, v in ipairs(objects) do + if v then + local e = v:get_luaentity() + if e and e.name == "signs_lib:text" then + obj = v + end + end end end - signs_lib.update_sign(pos) - return true + + if not obj then + obj = minetest.add_entity(pos, "signs_lib:text") + end + + local yaw = def.entity_info.yaw[node.param2 + 1] + local pitch = 0 + + if not string.find(node.name, "onpole") and not string.find(node.name, "hanging") then + local rot90 = math.pi/2 + + if def.paramtype2 == "wallmounted" then + if node.param2 == 1 then -- on floor + pitch = -rot90 + yaw = 0 + elseif node.param2 == 0 then -- on ceiling + pitch = rot90 + yaw = math.pi + end + elseif def.paramtype2 == "facedir" then + if node.param2 == 4 then + pitch = -rot90 + yaw = 0 + elseif node.param2 == 6 then + pitch = rot90 + yaw = math.pi + end + end + end + + if yaw then + obj:set_rotation({x = pitch, y = yaw, z=0}) + + if not texture then + obj:set_properties({ + mesh = def.entity_info.mesh, + visual_size = text_scale, + }) + else + obj:set_properties({ + mesh = def.entity_info.mesh, + visual_size = text_scale, + textures={texture}, + }) + end + end +end + +function signs_lib.set_obj_text(pos, text) + local split = signs_lib.split_lines_and_words + local text_ansi = Utf8ToAnsi(text) + local n = minetest.registered_nodes[minetest.get_node(pos).name] + signs_lib.delete_objects(pos) + signs_lib.spawn_entity(pos, signs_lib.make_sign_texture(split(text_ansi), pos) ) end -local DEFAULT_TEXT_SCALE = {x=10, y=10} +-- rotation + +function signs_lib.handle_rotation(pos, node, user, mode) + if not signs_lib.can_modify(pos, user) + or mode ~= screwdriver.ROTATE_FACE then + return false + end + local newparam2 + local tpos = pos + local def = minetest.registered_items[node.name] + + if string.match(node.name, "_onpole") then + if not string.match(node.name, "_horiz") then + newparam2 = signs_lib.rotate_walldir_simple[node.param2] or 4 + local t = signs_lib.wall_fdir_to_back_left + + if def.paramtype2 ~= "wallmounted" then + newparam2 = signs_lib.rotate_facedir_simple[node.param2] or 0 + t = signs_lib.fdir_to_back_left + end + + tpos = { + x = pos.x + t[node.param2][1], + y = pos.y, + z = pos.z + t[node.param2][2] + } + else + -- flip the sign to the other side of the horizontal pole + newparam2 = signs_lib.flip_walldir[node.param2] or 4 + local t = signs_lib.wall_fdir_flip_to_back + + if def.paramtype2 ~= "wallmounted" then + newparam2 = signs_lib.flip_facedir[node.param2] or 0 + t = signs_lib.fdir_flip_to_back + end + + tpos = { + x = pos.x + t[node.param2][1], + y = pos.y, + z = pos.z + t[node.param2][2] + } + end + local node2 = minetest.get_node(tpos) + local def2 = minetest.registered_items[node2.name] + if not def2 or not def2.buildable_to then return true end -- undefined, or not buildable_to. + + minetest.set_node(tpos, {name = node.name, param2 = newparam2}) + minetest.get_meta(tpos):from_table(minetest.get_meta(pos):to_table()) + minetest.remove_node(pos) + signs_lib.delete_objects(pos) + elseif string.match(node.name, "_hanging") or string.match(node.name, "yard") then + minetest.swap_node(tpos, { name = node.name, param2 = signs_lib.rotate_facedir_simple[node.param2] or 0 }) + elseif minetest.registered_items[node.name].paramtype2 == "wallmounted" then + minetest.swap_node(tpos, { name = node.name, param2 = signs_lib.rotate_walldir[node.param2] or 0 }) + else + minetest.swap_node(tpos, { name = node.name, param2 = signs_lib.rotate_facedir[node.param2] or 0 }) + end + + signs_lib.update_sign(tpos) + return true +end -- infinite stacks @@ -204,15 +424,6 @@ local fences_with_sign = { } -- some local helper functions -local function split_lines_and_words(text) - if not text then return end - local lines = { } - for _, line in ipairs(text:split("\n")) do - table.insert(lines, line:split(" ")) - end - return lines -end - local math_max = math.max local function fill_line(x, y, w, c, font_size, colorbgw) @@ -354,25 +565,33 @@ local function make_line_texture(line, lineno, pos, line_width, line_height, cwi return table.concat(texture), lineno end -local function make_sign_texture(lines, pos) +function signs_lib.make_sign_texture(lines, pos) local node = minetest.get_node(pos) + local meta = minetest.get_meta(pos) + local def = minetest.registered_items[node.name] + if not def or not def.entity_info then return end local font_size local line_width local line_height local char_width local colorbgw + local widemult = 1 + + if meta:get_int("widefont") == 1 then + widemult = 0.5 + end if def.font_size and def.font_size == 31 then font_size = 31 - line_width = math.floor(signs_lib.avgwidth31 * def.chars_per_line) * def.horiz_scaling + line_width = math.floor(signs_lib.avgwidth31 * def.chars_per_line) * (def.horiz_scaling * widemult) line_height = signs_lib.lineheight31 char_width = signs_lib.charwidth31 colorbgw = signs_lib.colorbgw31 else font_size = 15 - line_width = math.floor(signs_lib.avgwidth15 * def.chars_per_line) * def.horiz_scaling + line_width = math.floor(signs_lib.avgwidth15 * def.chars_per_line) * (def.horiz_scaling * widemult) line_height = signs_lib.lineheight15 char_width = signs_lib.charwidth15 colorbgw = signs_lib.colorbgw15 @@ -391,42 +610,49 @@ local function make_sign_texture(lines, pos) return table.concat(texture, "") end -local function set_obj_text(obj, text, x, pos) - local split = split_lines_and_words - local text_ansi = Utf8ToAnsi(text) - local n = minetest.registered_nodes[minetest.get_node(pos).name] - local text_scale = (n and n.text_scale) or DEFAULT_TEXT_SCALE - local texture = make_sign_texture(split(text_ansi), pos) - obj:set_properties({ - textures={texture}, - visual_size = text_scale, - }) +function signs_lib.split_lines_and_words(text) + if not text then return end + local lines = { } + for _, line in ipairs(text:split("\n", true)) do + table.insert(lines, line:split(" ")) + end + return lines end -signs_lib.construct_sign = function(pos) - local meta = minetest.get_meta(pos) - meta:set_string( - "formspec", - "size[6,4]".. +function signs_lib.construct_sign(pos) + local form = "size[6,4]".. "textarea[0,-0.3;6.5,3;text;;${text}]".. - "button_exit[2,3.4;2,1;ok;"..S("Write").."]".. - "background[-0.5,-0.5;7,5;signs_lib_sign_bg.jpg]") - meta:set_string("infotext", "") + "background[-0.5,-0.5;7,5;signs_lib_sign_bg.jpg]" + local node = minetest.get_node(pos) + local def = minetest.registered_items[node.name] + local meta = minetest.get_meta(pos) + + if def.allow_widefont then + local state = "off" + if meta:get_int("widefont") == 1 then state = "on" end + form = form.."label[1,3.4;Use wide font]".. + "image_button[1.1,3.7;1,0.6;signs_lib_switch_".. + state..".png;".. + state..";;;false;signs_lib_switch_interm.png]".. + "button_exit[3,3.4;2,1;ok;"..S("Write").."]" + else + form = form.."button_exit[2,3.4;2,1;ok;"..S("Write").."]" + end + + meta:set_string("formspec", form) + local i = meta:get_string("infotext") + if i == "" then -- it wasn't even set, so set it. + meta:set_string("infotext", "") + end end function signs_lib.destruct_sign(pos) - local objects = minetest.get_objects_inside_radius(pos, 0.5) - for _, v in ipairs(objects) do - local e = v:get_luaentity() - if e and e.name == "signs_lib:text" then - v:remove() - end - end + signs_lib.delete_objects(pos) end local function make_infotext(text) text = trim_input(text) - local lines = split_lines_and_words(text) or {} + local lines = signs_lib.split_lines_and_words(text) or {} local lines2 = { } for _, line in ipairs(lines) do table.insert(lines2, (table.concat(line, " "):gsub("#[0-9a-fA-F]", ""):gsub("##", "#"))) @@ -441,50 +667,46 @@ function signs_lib.update_sign(pos, fields) text = trim_input(text) local owner = meta:get_string("owner") - ownstr = "" + local ownstr = "" if owner ~= "" then ownstr = S("Locked sign, owned by @1\n", owner) end meta:set_string("text", text) meta:set_string("infotext", ownstr..make_infotext(text).." ") - - local objects = minetest.get_objects_inside_radius(pos, 0.5) - local found - for _, v in ipairs(objects) do - local e = v:get_luaentity() - if e and e.name == "signs_lib:text" then - if found then - v:remove() - else - set_obj_text(v, text, nil, pos) - found = true - end - end - end - if found then - return - end - - -- if there is no entity - local signnode = minetest.get_node(pos) - local signname = signnode.name - local def = minetest.registered_items[signname] - if not def.entity_info or not def.entity_info.yaw[signnode.param2 + 1] then return end - local obj = minetest.add_entity(pos, "signs_lib:text") - - obj:setyaw(def.entity_info.yaw[signnode.param2 + 1]) - obj:set_properties({ - mesh = def.entity_info.mesh, - }) + signs_lib.set_obj_text(pos, text) end function signs_lib.receive_fields(pos, formname, fields, sender) - if fields and fields.text and fields.ok and signs_lib.can_modify(pos, sender) then + + if not fields or not signs_lib.can_modify(pos, sender) then return end + + if fields.text and fields.ok then minetest.log("action", S("@1 wrote \"@2\" to sign at @3", (sender:get_player_name() or ""), fields.text:gsub('\\', '\\\\'):gsub("\n", "\\n"), minetest.pos_to_string(pos) )) signs_lib.update_sign(pos, fields) + elseif fields.on or fields.off then + local node = minetest.get_node(pos) + local meta = minetest.get_meta(pos) + local change + + if fields.on and meta:get_int("widefont") == 1 then + meta:set_int("widefont", 0) + change = true + elseif fields.off and meta:get_int("widefont") == 0 then + meta:set_int("widefont", 1) + change = true + end + if change then + minetest.log("action", S("@1 flipped the wide-font switch to \"@2\" at @3", + (sender:get_player_name() or ""), + (fields.on and "off" or "on"), + minetest.pos_to_string(pos) + )) + signs_lib.construct_sign(pos) + signs_lib.update_sign(pos, fields) + end end end @@ -508,34 +730,10 @@ function signs_lib.can_modify(pos, player) return false end -local signs_text_on_activate = function(self) - local pos = self.object:getpos() - local meta = minetest.get_meta(pos) - local signnode = minetest.get_node(pos) - local signname = signnode.name - local def = minetest.registered_items[signname] - local text = meta:get_string("text") - if text and def and def.entity_info then - text = trim_input(text) - set_obj_text(self.object, text, nil, pos) - self.object:set_properties({ - mesh = def.entity_info.mesh, - }) - end -end - -minetest.register_entity("signs_lib:text", { - collisionbox = { 0, 0, 0, 0, 0, 0 }, - visual = "mesh", - mesh = "signs_lib_basic_entity.obj", - textures = {}, - on_activate = signs_text_on_activate, -}) - -- make selection boxes -- sizex/sizey specified in inches because that's what MUTCD uses. -function signs_lib.make_selection_boxes(sizex, sizey, onpole, xoffs, yoffs, zoffs, fdir) +function signs_lib.make_selection_boxes(sizex, sizey, foo, xoffs, yoffs, zoffs, is_facedir) local tx = (sizex * 0.0254 ) / 2 local ty = (sizey * 0.0254 ) / 2 @@ -543,34 +741,18 @@ function signs_lib.make_selection_boxes(sizex, sizey, onpole, xoffs, yoffs, zoff local yo = yoffs and yoffs * 0.0254 or 0 local zo = zoffs and zoffs * 0.0254 or 0 - if onpole == "_onpole" then - if not fdir then - return { - type = "wallmounted", - wall_side = { -0.5 - 0.3125 + zo, -ty + yo, -tx + xo, -0.4375 - 0.3125 + zo, ty + yo , tx + xo }, - wall_top = {-0.5, -0.5, -0.5, 0.5, 0.5, 0.5 }, - wall_bottom = {-0.5, -0.5, -0.5, 0.5, 0.5, 0.5 }, - } - else - return { - type = "fixed", - fixed = { -tx + xo, -ty + yo, 0.5 + 0.3125 + zo, tx + xo, ty + yo, 0.4375 + 0.3125 + zo } - } - end + if not is_facedir then + return { + type = "wallmounted", + wall_side = { -0.5 + zo, -ty + yo, -tx + xo, -0.4375 + zo, ty + yo, tx + xo }, + wall_top = { -tx - xo, 0.5 + zo, -ty + yo, tx - xo, 0.4375 + zo, ty + yo}, + wall_bottom = { -tx - xo, -0.5 + zo, -ty + yo, tx - xo, -0.4375 + zo, ty + yo } + } else - if not fdir then - return { - type = "wallmounted", - wall_side = { -0.5, -ty, -tx, -0.4375, ty, tx }, - wall_top = { -tx - xo, 0.5 + zo, -ty + yo, tx - xo, 0.4375 + zo, ty + yo}, - wall_bottom = { -tx - xo, -0.5 + zo, -ty + yo, tx - xo, -0.4375 + zo, ty + yo } - } - else - return { - type = "fixed", - fixed = { -tx + xo, -ty + yo, 0.5 + zo, tx + xo, ty + yo, 0.4375 + zo} - } - end + return { + type = "fixed", + fixed = { -tx + xo, -ty + yo, 0.5 + zo, tx + xo, ty + yo, 0.4375 + zo} + } end end @@ -579,26 +761,101 @@ function signs_lib.check_for_pole(pos, pointed_thing) local pnode = minetest.get_node(ppos) local pdef = minetest.registered_items[pnode.name] - if signs_lib.allowed_poles[pnode.name] - or (pdef and pdef.drawtype == "fencelike") - or string.find(pnode.name, "default:fence_") - or string.find(pnode.name, "_post") - or string.find(pnode.name, "fencepost") - or (pnode.name == "streets:bigpole" and pnode.param2 < 4) - or (pnode.name == "streets:bigpole" and pnode.param2 > 19 and pnode.param2 < 24) then + if not pdef then return end + + if signs_lib.check_for_ceiling(pointed_thing) or signs_lib.check_for_floor(pointed_thing) then + return false + end + + if type(pdef.check_for_pole) == "function" then + local node = minetest.get_node(pos) + local def = minetest.registered_items[node.name] + return pdef.check_for_pole(pos, node, def, ppos, pnode, pdef) + elseif pdef.check_for_pole + or pdef.drawtype == "fencelike" + or string.find(pnode.name, "_post") + or string.find(pnode.name, "fencepost") then return true end end -function signs_lib.after_place_node(pos, placer, itemstack, pointed_thing, locked) +function signs_lib.check_for_horizontal_pole(pos, pointed_thing) local ppos = minetest.get_pointed_thing_position(pointed_thing) local pnode = minetest.get_node(ppos) local pdef = minetest.registered_items[pnode.name] + + if not pdef then return end + + if signs_lib.check_for_ceiling(pointed_thing) or signs_lib.check_for_floor(pointed_thing) then + return false + end + + if type(pdef.check_for_horiz_pole) == "function" then + local node = minetest.get_node(pos) + local def = minetest.registered_items[node.name] + return pdef.check_for_horiz_pole(pos, node, def, ppos, pnode, pdef) + end +end + +function signs_lib.check_for_ceiling(pointed_thing) + if pointed_thing.above.x == pointed_thing.under.x + and pointed_thing.above.z == pointed_thing.under.z + and pointed_thing.above.y < pointed_thing.under.y then + return true + end +end + +function signs_lib.check_for_floor(pointed_thing) + if pointed_thing.above.x == pointed_thing.under.x + and pointed_thing.above.z == pointed_thing.under.z + and pointed_thing.above.y > pointed_thing.under.y then + return true + end +end + +function signs_lib.after_place_node(pos, placer, itemstack, pointed_thing, locked) local playername = placer:get_player_name() + local signname = itemstack:get_name() + local no_wall_name = string.gsub(signname, "_wall", "") - if signs_lib.check_for_pole(pos, pointed_thing) then + local def = minetest.registered_items[signname] + + local ppos = minetest.get_pointed_thing_position(pointed_thing) + local pnode = minetest.get_node(ppos) + local pdef = minetest.registered_items[pnode.name] + + if def.allow_onpole and signs_lib.check_for_pole(pos, pointed_thing) then + local newparam2 + local lookdir = minetest.yaw_to_dir(placer:get_look_horizontal()) + if def.paramtype2 == "wallmounted" then + newparam2 = minetest.dir_to_wallmounted(lookdir) + else + newparam2 = minetest.dir_to_facedir(lookdir) + end + local node = minetest.get_node(pos) + minetest.swap_node(pos, {name = no_wall_name.."_onpole", param2 = newparam2}) + elseif def.allow_onpole_horizontal and signs_lib.check_for_horizontal_pole(pos, pointed_thing) then + local newparam2 + local lookdir = minetest.yaw_to_dir(placer:get_look_horizontal()) + if def.paramtype2 == "wallmounted" then + newparam2 = minetest.dir_to_wallmounted(lookdir) + else + newparam2 = minetest.dir_to_facedir(lookdir) + end + local node = minetest.get_node(pos) + minetest.swap_node(pos, {name = no_wall_name.."_onpole_horiz", param2 = newparam2}) + elseif def.allow_hanging and signs_lib.check_for_ceiling(pointed_thing) then + local newparam2 = minetest.dir_to_facedir(placer:get_look_dir()) local node = minetest.get_node(pos) - minetest.swap_node(pos, {name = itemstack:get_name().."_onpole", param2 = node.param2}) + minetest.swap_node(pos, {name = no_wall_name.."_hanging", param2 = newparam2}) + elseif def.allow_yard and signs_lib.check_for_floor(pointed_thing) then + local newparam2 = minetest.dir_to_facedir(placer:get_look_dir()) + local node = minetest.get_node(pos) + minetest.swap_node(pos, {name = no_wall_name.."_yard", param2 = newparam2}) + elseif def.paramtype2 == "facedir" and signs_lib.check_for_ceiling(pointed_thing) then + minetest.swap_node(pos, {name = signname, param2 = 6}) + elseif def.paramtype2 == "facedir" and signs_lib.check_for_floor(pointed_thing) then + minetest.swap_node(pos, {name = signname, param2 = 4}) end if locked then local meta = minetest.get_meta(pos) @@ -611,6 +868,197 @@ function signs_lib.register_fence_with_sign() minetest.log("warning", "[signs_lib] ".."Attempt to call no longer used function signs_lib.register_fence_with_sign()") end +function signs_lib.register_sign(name, raw_def) + local def = table.copy(raw_def) + + if raw_def.entity_info == "standard" then + def.entity_info = { + mesh = "signs_lib_standard_sign_entity_wall.obj", + yaw = signs_lib.wallmounted_yaw + } + elseif raw_def.entity_info then + def.entity_info = raw_def.entity_info + end + + def.after_place_node = raw_def.after_place_node or signs_lib.after_place_node + + if raw_def.entity_info then + def.on_rightclick = raw_def.on_rightclick or signs_lib.construct_sign + def.on_construct = raw_def.on_construct or signs_lib.construct_sign + def.on_destruct = raw_def.on_destruct or signs_lib.destruct_sign + def.on_receive_fields = raw_def.on_receive_fields or signs_lib.receive_fields + def.on_punch = raw_def.on_punch or signs_lib.update_sign + def.number_of_lines = raw_def.number_of_lines or signs_lib.standard_lines + def.horiz_scaling = raw_def.horiz_scaling or signs_lib.standard_hscale + def.vert_scaling = raw_def.vert_scaling or signs_lib.standard_vscale + def.line_spacing = raw_def.line_spacing or signs_lib.standard_lspace + def.font_size = raw_def.font_size or signs_lib.standard_fsize + def.x_offset = raw_def.x_offset or signs_lib.standard_xoffs + def.y_offset = raw_def.y_offset or signs_lib.standard_yoffs + def.chars_per_line = raw_def.chars_per_line or signs_lib.standard_cpl + def.default_color = raw_def.default_color or "0" + if raw_def.locked and not raw_def.after_place_node then + def.after_place_node = function(pos, placer, itemstack, pointed_thing) + signs_lib.after_place_node(pos, placer, itemstack, pointed_thing, true) + end + end + end + + def.paramtype = raw_def.paramtype or "light" + def.drawtype = raw_def.drawtype or "mesh" + def.mesh = raw_def.mesh or "signs_lib_standard_sign_wall.obj" + def.wield_image = raw_def.wield_image or def.inventory_image + def.drop = raw_def.drop or name + def.sounds = raw_def.sounds or signs_lib.standard_wood_sign_sounds + def.paramtype2 = raw_def.paramtype2 or "wallmounted" + def.on_rotate = raw_def.on_rotate or signs_lib.handle_rotation + + if raw_def.groups then + def.groups = raw_def.groups + else + def.groups = signs_lib.standard_wood_groups + end + + local cbox = signs_lib.make_selection_boxes(35, 25) + + def.selection_box = raw_def.selection_box or cbox + def.node_box = table.copy(raw_def.node_box or raw_def.selection_box or cbox) + + if def.sunlight_propagates ~= false then + def.sunlight_propagates = true + end + + def.tiles[3] = "signs_lib_blank.png" + def.tiles[4] = "signs_lib_blank.png" + def.tiles[5] = "signs_lib_blank.png" + def.tiles[6] = "signs_lib_blank.png" + + minetest.register_node(":"..name, def) + table.insert(signs_lib.lbm_restore_nodes, name) + + local no_wall_name = string.gsub(name, "_wall", "") + + local othermounts_def = table.copy(def) + + if raw_def.allow_onpole or raw_def.allow_onpole_horizontal then + + local offset = 0.3125 + if othermounts_def.uses_slim_pole_mount then + offset = 0.35 + end + + othermounts_def.selection_box = raw_def.onpole_selection_box or othermounts_def.selection_box + othermounts_def.node_box = raw_def.onpole_node_box or othermounts_def.selection_box + + if othermounts_def.paramtype2 == "wallmounted" then + othermounts_def.node_box.wall_side[1] = def.node_box.wall_side[1] - offset + othermounts_def.node_box.wall_side[4] = def.node_box.wall_side[4] - offset + + othermounts_def.selection_box.wall_side[1] = def.selection_box.wall_side[1] - offset + othermounts_def.selection_box.wall_side[4] = def.selection_box.wall_side[4] - offset + else + othermounts_def.node_box.fixed[3] = def.node_box.fixed[3] + offset + othermounts_def.node_box.fixed[6] = def.node_box.fixed[6] + offset + + othermounts_def.selection_box.fixed[3] = def.selection_box.fixed[3] + offset + othermounts_def.selection_box.fixed[6] = def.selection_box.fixed[6] + offset + end + + othermounts_def.groups.not_in_creative_inventory = 1 + othermounts_def.mesh = raw_def.onpole_mesh or string.gsub(othermounts_def.mesh, "wall.obj$", "onpole.obj") + + if othermounts_def.entity_info then + othermounts_def.entity_info.mesh = string.gsub(othermounts_def.entity_info.mesh, "entity_wall.obj$", "entity_onpole.obj") + end + end + + -- setting one of item 3 or 4 to a texture and leaving the other "blank", + -- reveals either the vertical or horizontal pole mount part of the model + + if raw_def.allow_onpole then + othermounts_def.tiles[3] = raw_def.tiles[3] or "signs_lib_pole_mount.png" + othermounts_def.tiles[4] = "signs_lib_blank.png" + othermounts_def.tiles[5] = "signs_lib_blank.png" + othermounts_def.tiles[6] = "signs_lib_blank.png" + + minetest.register_node(":"..no_wall_name.."_onpole", othermounts_def) + table.insert(signs_lib.lbm_restore_nodes, no_wall_name.."_onpole") + end + + if raw_def.allow_onpole_horizontal then + local onpole_horiz_def = table.copy(othermounts_def) + + onpole_horiz_def.tiles[3] = "signs_lib_blank.png" + onpole_horiz_def.tiles[4] = raw_def.tiles[3] or "signs_lib_pole_mount.png" + onpole_horiz_def.tiles[5] = "signs_lib_blank.png" + onpole_horiz_def.tiles[6] = "signs_lib_blank.png" + + minetest.register_node(":"..no_wall_name.."_onpole_horiz", onpole_horiz_def) + table.insert(signs_lib.lbm_restore_nodes, no_wall_name.."_onpole_horiz") + end + + if raw_def.allow_hanging then + + local hanging_def = table.copy(def) + hanging_def.paramtype2 = "facedir" + + local hcbox = signs_lib.make_selection_boxes(35, 32, nil, 0, 3, -18.5, true) + + hanging_def.selection_box = raw_def.hanging_selection_box or hcbox + hanging_def.node_box = raw_def.hanging_node_box or raw_def.hanging_selection_box or hcbox + + hanging_def.groups.not_in_creative_inventory = 1 + hanging_def.tiles[3] = raw_def.tiles[5] or "signs_lib_hangers.png" + hanging_def.tiles[4] = "signs_lib_blank.png" + hanging_def.tiles[5] = "signs_lib_blank.png" + hanging_def.tiles[6] = "signs_lib_blank.png" + + hanging_def.mesh = raw_def.hanging_mesh or string.gsub(string.gsub(hanging_def.mesh, "wall.obj$", "hanging.obj"), "_facedir", "") + + if hanging_def.entity_info then + hanging_def.entity_info.mesh = string.gsub(string.gsub(hanging_def.entity_info.mesh, "entity_wall.obj$", "entity_hanging.obj"), "_facedir", "") + hanging_def.entity_info.yaw = signs_lib.standard_yaw + end + + minetest.register_node(":"..no_wall_name.."_hanging", hanging_def) + table.insert(signs_lib.lbm_restore_nodes, no_wall_name.."_hanging") + end + + if raw_def.allow_yard then + + local ydef = table.copy(def) + ydef.paramtype2 = "facedir" + + local ycbox = signs_lib.make_selection_boxes(35, 34.5, false, 0, -1.25, -19.69, true) + + ydef.selection_box = raw_def.yard_selection_box or ycbox + ydef.tiles[3] = raw_def.tiles[6] or "default_wood.png" + ydef.tiles[4] = "signs_lib_blank.png" + ydef.tiles[5] = "signs_lib_blank.png" + ydef.tiles[6] = "signs_lib_blank.png" + + ydef.node_box = raw_def.yard_node_box or raw_def.yard_selection_box or ycbox + + ydef.groups.not_in_creative_inventory = 1 + ydef.mesh = raw_def.yard_mesh or string.gsub(string.gsub(ydef.mesh, "wall.obj$", "yard.obj"), "_facedir", "") + + if ydef.entity_info then + ydef.entity_info.mesh = string.gsub(string.gsub(ydef.entity_info.mesh, "entity_wall.obj$", "entity_yard.obj"), "_facedir", "") + ydef.entity_info.yaw = signs_lib.standard_yaw + end + + minetest.register_node(":"..no_wall_name.."_yard", ydef) + table.insert(signs_lib.lbm_restore_nodes, no_wall_name.."_yard") + end + + if raw_def.allow_widefont then + table.insert(signs_lib.old_widefont_signs, name.."_widefont") + table.insert(signs_lib.old_widefont_signs, name.."_widefont_onpole") + table.insert(signs_lib.old_widefont_signs, name.."_widefont_hanging") + table.insert(signs_lib.old_widefont_signs, name.."_widefont_yard") + end +end + -- restore signs' text after /clearobjects and the like, the next time -- a block is reloaded by the server. @@ -645,12 +1093,7 @@ minetest.register_lbm({ local oldfence = signs_lib.old_fenceposts[node.name] local newsign = signs_lib.old_fenceposts_replacement_signs[node.name] - for _, v in ipairs(minetest.get_objects_inside_radius(pos, 0.5)) do - local e = v:get_luaentity() - if e and e.name == "signs_lib:text" then - v:remove() - end - end + signs_lib.delete_objects(pos) local oldmeta = minetest.get_meta(pos):to_table() minetest.set_node(pos, {name = oldfence}) @@ -661,3 +1104,79 @@ minetest.register_lbm({ end end }) + +-- Convert widefont sign nodes to use one base node with meta flag to select wide mode + +minetest.register_lbm({ + nodenames = signs_lib.old_widefont_signs, + name = "signs_lib:convert_widefont_signs", + label = "Convert widefont sign nodes", + run_at_every_load = false, + action = function(pos, node) + local basename = string.gsub(node.name, "_widefont", "") + minetest.swap_node(pos, {name = basename, param2 = node.param2}) + local meta = minetest.get_meta(pos) + meta:set_int("widefont", 1) + signs_lib.update_sign(pos) + end +}) + +-- Maintain a list of currently-loaded blocks +minetest.register_lbm({ + nodenames = {"group:sign"}, + name = "signs_lib:update_block_list", + label = "Update list of loaded blocks, log only those with signs", + run_at_every_load = true, + action = function(pos, node) + -- yeah, yeah... I know I'm hashing a block pos, but it's still just a set of coords + local hash = minetest.hash_node_position(vector.floor(vector.divide(pos, core.MAP_BLOCKSIZE))) + if not signs_lib.block_list[hash] then + signs_lib.block_list[hash] = true + signs_lib.totalblocks = signs_lib.totalblocks + 1 + end + end +}) + +minetest.register_chatcommand("regen_signs", { + params = "", + privs = {server = true}, + description = "Skims through all currently-loaded sign-bearing mapblocks, clears away any entities within each sign's node space, and regenerates their text entities, if any.", + func = function(player_name, params) + local allsigns = {} + local totalsigns = 0 + for b in pairs(signs_lib.block_list) do + local blockpos = minetest.get_position_from_hash(b) + local pos1 = vector.multiply(blockpos, core.MAP_BLOCKSIZE) + local pos2 = vector.add(pos1, core.MAP_BLOCKSIZE - 1) + if minetest.get_node_or_nil(vector.add(pos1, core.MAP_BLOCKSIZE/2)) then + local signs_in_block = minetest.find_nodes_in_area(pos1, pos2, {"group:sign"}) + allsigns[#allsigns + 1] = signs_in_block + totalsigns = totalsigns + #signs_in_block + else + signs_lib.block_list[b] = nil -- if the block is no longer loaded, remove it from the table + signs_lib.totalblocks = signs_lib.totalblocks - 1 + end + end + if signs_lib.totalblocks < 0 then signs_lib.totalblocks = 0 end + if totalsigns == 0 then + minetest.chat_send_player(player_name, "There are no signs in the currently-loaded terrain.") + signs_lib.block_list = {} + return + end + + minetest.chat_send_player(player_name, "Found a total of "..totalsigns.." sign nodes across "..signs_lib.totalblocks.." blocks.") + minetest.chat_send_player(player_name, "Regenerating sign entities...") + + for _, b in pairs(allsigns) do + for _, pos in ipairs(b) do + signs_lib.delete_objects(pos) + local node = minetest.get_node(pos) + local def = minetest.registered_items[node.name] + if def and def.entity_info then + signs_lib.update_sign(pos) + end + end + end + minetest.chat_send_player(player_name, "Finished.") + end +})