From 01fb71d2eb5d1dd41c338bef0bcc2e26a259047d Mon Sep 17 00:00:00 2001 From: FaceDeer Date: Tue, 10 Jan 2017 00:32:08 -0700 Subject: renaming class definition files --- class_layout.lua | 345 +++++++++++++++++++++++++++++++++++++++++++++++++++++ class_pointset.lua | 73 ++++++++++++ init.lua | 3 +- pointset.lua | 73 ------------ util.lua | 1 - util_layout.lua | 345 ----------------------------------------------------- 6 files changed, 420 insertions(+), 420 deletions(-) create mode 100644 class_layout.lua create mode 100644 class_pointset.lua delete mode 100644 pointset.lua delete mode 100644 util_layout.lua diff --git a/class_layout.lua b/class_layout.lua new file mode 100644 index 0000000..b7311c5 --- /dev/null +++ b/class_layout.lua @@ -0,0 +1,345 @@ +DigtronLayout = {} +DigtronLayout.__index = DigtronLayout + +------------------------------------------------------------------------- +-- Creation + +local get_node_image = function(pos, node) + local node_image = {node=node, pos={x=pos.x, y=pos.y, z=pos.z}} + node_image.paramtype2 = minetest.registered_nodes[node.name].paramtype2 + local meta = minetest.get_meta(pos) + node_image.meta = meta:to_table() + + -- Record what kind of thing we've got in a builder node so its facing can be rotated properly + if minetest.get_item_group(node.name, "digtron") == 4 then + local build_item = node_image.meta.inventory.main[1] + if build_item ~= "" then + local build_item_def = minetest.registered_nodes[ItemStack(build_item):get_name()] + node_image.build_item_paramtype2 = build_item_def.paramtype2 + end + end + return node_image +end + +function DigtronLayout.create(pos, player) + local self = {} + setmetatable(self,DigtronLayout) + + --initialize. We're assuming that the start position is a controller digtron, should be a safe assumption since only the controller node should call this + self.traction = 0 + self.all = {} + self.inventories = {} + self.fuelstores = {} + self.diggers = {} + self.builders = {} + self.extents = {} + self.water_touching = false + self.lava_touching = false + self.protected = Pointset.create() -- if any nodes we look at are protected, make note of that. That way we don't need to keep re-testing protection state later. + self.old_pos_pointset = Pointset.create() -- For tracking original location of nodes if we do transformations on the Digtron + self.nodes_dug = Pointset.create() -- For tracking adjacent nodes that will have been dug by digger heads in future + self.contains_protected_node = false -- used to indicate if at least one node in this digtron array is protected from the player. + self.controller = {x=pos.x, y=pos.y, z=pos.z} --Make a deep copy of the pos parameter just in case the calling code wants to play silly buggers with it + + table.insert(self.all, get_node_image(pos, minetest.get_node(pos))) -- We never visit the source node, so insert it into the all table a priori. Revisit this if a controller node is created that contains fuel or inventory or whatever. + + self.extents.max_x = pos.x + self.extents.min_x = pos.x + self.extents.max_y = pos.y + self.extents.min_y = pos.y + self.extents.max_z = pos.z + self.extents.min_z = pos.z + + -- temporary pointsets used while searching + local to_test = Pointset.create() + local tested = Pointset.create() + + tested:set(pos.x, pos.y, pos.z, true) + to_test:set(pos.x + 1, pos.y, pos.z, true) + to_test:set(pos.x - 1, pos.y, pos.z, true) + to_test:set(pos.x, pos.y + 1, pos.z, true) + to_test:set(pos.x, pos.y - 1, pos.z, true) + to_test:set(pos.x, pos.y, pos.z + 1, true) + to_test:set(pos.x, pos.y, pos.z - 1, true) + + if minetest.is_protected(pos, player:get_player_name()) and not minetest.check_player_privs(player, "protection_bypass") then + self.protected:set(pos.x, pos.y, pos.z, true) + self.contains_protected_node = true + end + + -- Do a loop on to_test positions, adding new to_test positions as we find digtron nodes. This is a flood fill operation + -- that follows node faces (no diagonals) + local testpos, _ = to_test:pop() + while testpos ~= nil do + tested:set(testpos.x, testpos.y, testpos.z, true) -- track nodes we've looked at to prevent infinite loops + local node = minetest.get_node(testpos) + + if node.name == "ignore" then + --buildtron array is next to unloaded nodes, too dangerous to do anything. Abort. + return nil + end + + if minetest.get_item_group(node.name, "water") ~= 0 then + self.water_touching = true + elseif minetest.get_item_group(node.name, "lava") ~= 0 then + self.lava_touching = true + if digtron.lava_impassible == true then + self.protected:set(testpos.x, testpos.y, testpos.z, true) + end + end + + local group_number = minetest.get_item_group(node.name, "digtron") + if group_number > 0 then + --found one. Add it to the digtrons output + local node_image = get_node_image(testpos, node) + + table.insert(self.all, node_image) + + -- add a reference to this node's position to special node lists + if group_number == 2 then + table.insert(self.inventories, node_image) + elseif group_number == 3 then + table.insert(self.diggers, node_image) + elseif group_number == 4 then + table.insert(self.builders, node_image) + elseif group_number == 5 then + table.insert(self.fuelstores, node_image) + elseif group_number == 6 then + table.insert(self.inventories, node_image) + table.insert(self.fuelstores, node_image) + end + + if minetest.is_protected(pos, player:get_player_name()) and not minetest.check_player_privs(player, "protection_bypass") then + self.contains_protected_node = true + end + + -- update extents + self.extents.max_x = math.max(self.extents.max_x, testpos.x) + self.extents.min_x = math.min(self.extents.min_x, testpos.x) + self.extents.max_y = math.max(self.extents.max_y, testpos.y) + self.extents.min_y = math.min(self.extents.min_y, testpos.y) + self.extents.max_z = math.max(self.extents.max_z, testpos.z) + self.extents.min_z = math.min(self.extents.min_z, testpos.z) + + --queue up potential new test points adjacent to this digtron node + to_test:set_if_not_in(tested, testpos.x + 1, testpos.y, testpos.z, true) + to_test:set_if_not_in(tested, testpos.x - 1, testpos.y, testpos.z, true) + to_test:set_if_not_in(tested, testpos.x, testpos.y + 1, testpos.z, true) + to_test:set_if_not_in(tested, testpos.x, testpos.y - 1, testpos.z, true) + to_test:set_if_not_in(tested, testpos.x, testpos.y, testpos.z + 1, true) + to_test:set_if_not_in(tested, testpos.x, testpos.y, testpos.z - 1, true) + elseif minetest.registered_nodes[node.name].buildable_to ~= true then + -- Tracks whether the digtron is hovering in mid-air. If any part of the digtron array touches something solid it gains traction. + self.traction = self.traction + 1 + end + + testpos, _ = to_test:pop() + end + + return self +end + +------------------------------------------------------------------------ +-- Rotation + +local facedir_rotate = { + ['x'] = { + [-1] = {[0]=4, 5, 6, 7, 22, 23, 20, 21, 0, 1, 2, 3, 13, 14, 15, 12, 19, 16, 17, 18, 10, 11, 8, 9}, -- 270 degrees + [1] = {[0]=8, 9, 10, 11, 0, 1, 2, 3, 22, 23, 20, 21, 15, 12, 13, 14, 17, 18, 19, 16, 6, 7, 4, 5}, -- 90 degrees + }, + ['y'] = { + [-1] = {[0]=3, 0, 1, 2, 19, 16, 17, 18, 15, 12, 13, 14, 7, 4, 5, 6, 11, 8, 9, 10, 21, 22, 23, 20}, -- 270 degrees + [1] = {[0]=1, 2, 3, 0, 13, 14, 15, 12, 17, 18, 19, 16, 9, 10, 11, 8, 5, 6, 7, 4, 23, 20, 21, 22}, -- 90 degrees + }, + ['z'] = { + [-1] = {[0]=16, 17, 18, 19, 5, 6, 7, 4, 11, 8, 9, 10, 0, 1, 2, 3, 20, 21, 22, 23, 12, 13, 14, 15}, -- 270 degrees + [1] = {[0]=12, 13, 14, 15, 7, 4, 5, 6, 9, 10, 11, 8, 20, 21, 22, 23, 0, 1, 2, 3, 16, 17, 18, 19}, -- 90 degrees + } +} + +local wallmounted_rotate = { + ['x'] = { + [-1] = {[0]=4, 5, 2, 3, 1, 0}, -- 270 degrees + [1] = {[0]=5, 4, 2, 3, 0, 1}, -- 90 degrees + }, + ['y'] = { + [-1] = {[0]=0, 1, 4, 5, 3, 2}, -- 270 degrees + [1] = {[0]=0, 1, 5, 4, 2, 3}, -- 90 degrees + }, + ['z'] = { + [-1] = {[0]=3, 2, 0, 1, 4, 5}, -- 270 degrees + [1] = {[0]=2, 3, 1, 0, 4, 5}, -- 90 degrees + } +} + + --90 degrees CW about x-axis: (x, y, z) -> (x, -z, y) + --90 degrees CCW about x-axis: (x, y, z) -> (x, z, -y) + --90 degrees CW about y-axis: (x, y, z) -> (-z, y, x) + --90 degrees CCW about y-axis: (x, y, z) -> (z, y, -x) + --90 degrees CW about z-axis: (x, y, z) -> (y, -x, z) + --90 degrees CCW about z-axis: (x, y, z) -> (-y, x, z) +local rotate_pos = function(axis, direction, pos) + if axis == "x" then + if direction < 0 then + return {x= pos.x, y= -pos.z, z= pos.y} + else + return {x= pos.x, y= pos.z, z= -pos.y} + end + elseif axis == "y" then + if direction < 0 then + return {x= -pos.z, y= pos.y, z= pos.x} + else + return {x= pos.z, y= pos.y, z= -pos.x} + end + else + if direction < 0 then + return {x= -pos.y, y= pos.x, z= pos.z} + else + return {x= pos.y, y= -pos.x, z= pos.z} + end + end +end + +local rotate_node_image = function(node_image, origin, axis, direction, old_pos_pointset) + -- Facings + if node_image.paramtype2 == "wallmounted" then + node_image.node.param2 = wallmounted_rotate[axis][direction][node_image.node.param2] + elseif node_image.paramtype2 == "facedir" then + node_image.node.param2 = facedir_rotate[axis][direction][node_image.node.param2] + end + + if node_image.build_item_paramtype2 == "wallmounted" then + node_image.meta.fields.build_facing = wallmounted_rotate[axis][direction][tonumber(node_image.meta.fields.build_facing)] + elseif node_image.build_item_paramtype2 == "facedir" then + node_image.meta.fields.build_facing = facedir_rotate[axis][direction][tonumber(node_image.meta.fields.build_facing)] + end + + node_image.meta.fields.waiting = nil -- If we're rotating a controller that's in the "waiting" state, clear it. Otherwise it may stick like that. + + -- record the old location so we can destroy the old node if the rotation operation is possible + old_pos_pointset:set(node_image.pos.x, node_image.pos.y, node_image.pos.z, true) + + -- position in space relative to origin + local pos = vector.subtract(node_image.pos, origin) + pos = rotate_pos(axis, direction, pos) + -- Move back to original reference frame + node_image.pos = vector.add(pos, origin) + + return node_image +end + +-- Rotates 90 degrees widdershins around the axis defined by facedir (which in this case is pointing out the front of the node, so it needs to be converted into an upward-pointing axis internally) +function DigtronLayout.rotate_layout_image(self, facedir) + -- To convert this into the direction the "top" of the axel node is pointing in: + -- 0, 1, 2, 3 == (0,1,0) + -- 4, 5, 6, 7 == (0,0,1) + -- 8, 9, 10, 11 == (0,0,-1) + -- 12, 13, 14, 15 == (1,0,0) + -- 16, 17, 18, 19 == (-1,0,0) + -- 20, 21, 22, 23== (0,-1,0) + + local top = { + [0]={axis="y", dir=-1}, + {axis="z", dir=1}, + {axis="z", dir=-1}, + {axis="x", dir=1}, + {axis="x", dir=-1}, + {axis="y", dir=1}, + } + local params = top[math.floor(facedir/4)] + + for k, node_image in pairs(self.all) do + rotate_node_image(node_image, self.controller, params.axis, params.dir, self.old_pos_pointset) + end + return self +end + +----------------------------------------------------------------------------------------------- +-- Translation + +function DigtronLayout.move_layout_image(self, facing, player_name) + local extents = self.extents + local dir = digtron.facedir_to_dir_map[facing] + local increment + local filter + if dir == 1 then -- z+ + filter = "z" + increment = 1 + extents.max_z = extents.max_z + 1 + extents.min_z = extents.min_z + 1 + elseif dir == 2 then -- x+ + filter = "x" + increment = 1 + extents.max_x = extents.max_x + 1 + extents.min_x = extents.min_x + 1 + elseif dir == 3 then -- z- + filter = "z" + increment = -1 + extents.max_z = extents.max_z - 1 + extents.min_z = extents.min_z - 1 + elseif dir == 4 then -- x- + filter = "x" + increment = -1 + extents.max_x = extents.max_x - 1 + extents.min_x = extents.min_x - 1 + elseif dir == 5 then -- y- + filter = "y" + increment = -1 + extents.max_y = extents.max_y - 1 + extents.min_y = extents.min_y - 1 + elseif dir == 6 then -- y+ + filter = "y" + increment = 1 + extents.max_y = extents.max_y + 1 + extents.min_y = extents.min_y + 1 + end + + for k, node_image in pairs(self.all) do + self.old_pos_pointset:set(node_image.pos.x, node_image.pos.y, node_image.pos.z, true) + node_image.pos[filter] = node_image.pos[filter] + increment + self.nodes_dug:set(node_image.pos.x, node_image.pos.y, node_image.pos.z, false) -- we've moved a digtron node into this space, mark it so that we don't dig it. + -- TODO: log + end +end + +----------------------------------------------------------------------------------------------- +-- Writing to world + +function DigtronLayout.can_write_layout_image(self) + for k, node_image in pairs(self.all) do + -- check if the target node is buildable_to or is marked as part of the digtron that's moving + if not self.old_pos_pointset:get(node_image.pos.x, node_image.pos.y, node_image.pos.z) + and not minetest.registered_nodes[minetest.get_node(node_image.pos).name].buildable_to then + return false + --check if we're moving into a protected node + elseif self.protected:get(node_image.pos) then + return false + end + end + return true +end + +function DigtronLayout.write_layout_image(self) + -- destroy the old digtron + local oldpos, _ = self.old_pos_pointset:pop() + while oldpos ~= nil do + local old_def = minetest.registered_nodes[minetest.get_node(oldpos).name] + minetest.remove_node(oldpos) + if old_def.after_dig_node ~= nil then + old_def.after_dig_node(oldpos) + end + oldpos, _ = self.old_pos_pointset:pop() + end + + -- create the new one + for k, node_image in pairs(self.all) do + minetest.add_node(node_image.pos, node_image.node) + minetest.get_meta(node_image.pos):from_table(node_image.meta) + + local new_def = minetest.registered_nodes[node_image.node.name] + if new_def.after_place_node ~= nil then + new_def.after_place_node(node_image.pos) + end + end +end + diff --git a/class_pointset.lua b/class_pointset.lua new file mode 100644 index 0000000..5bfd22a --- /dev/null +++ b/class_pointset.lua @@ -0,0 +1,73 @@ +-- A simple special-purpose class, this is used for building up sets of three-dimensional points +-- I only added features to it as I needed them so may not be highly useful outside of this mod's context. + +Pointset = {} +Pointset.__index = Pointset + +function Pointset.create() + local set = {} + setmetatable(set,Pointset) + set.points = {} + return set +end + +function Pointset:set(x, y, z, value) + -- sets a value in the 3D array "points". + if self.points[x] == nil then + self.points[x] = {} + end + if self.points[x][y] == nil then + self.points[x][y] = {} + end + self.points[x][y][z] = value +end + +function Pointset:set_if_not_in(excluded, x, y, z, value) + -- If a value is not already set for this point in the 3D array "excluded", set it in "points" + if excluded:get(x, y, z) ~= nil then + return + end + self:set(x, y, z, value) +end + +function Pointset:get(x, y, z) + -- return a value from the 3D array "points" + if self.points[x] == nil or self.points[x][y] == nil then + return nil + end + return self.points[x][y][z] +end + +function Pointset:pop() + -- returns a point that's in the 3D array, and then removes it. + local pos = {} + local ytable + local ztable + local val + + local count = 0 + for _ in pairs(self.points) do count = count + 1 end + if count == 0 then + return nil + end + + pos.x, ytable = next(self.points) + pos.y, ztable = next(ytable) + pos.z, val = next(ztable) + + self.points[pos.x][pos.y][pos.z] = nil + + count = 0 + for _ in pairs(self.points[pos.x][pos.y]) do count = count + 1 end + if count == 0 then + self.points[pos.x][pos.y] = nil + end + + count = 0 + for _ in pairs(self.points[pos.x]) do count = count + 1 end + if count == 0 then + self.points[pos.x] = nil + end + + return pos, val +end \ No newline at end of file diff --git a/init.lua b/init.lua index af0492c..3ae536f 100644 --- a/init.lua +++ b/init.lua @@ -1,5 +1,6 @@ dofile( minetest.get_modpath( "digtron" ) .. "/util.lua" ) -dofile( minetest.get_modpath( "digtron" ) .. "/pointset.lua" ) +dofile( minetest.get_modpath( "digtron" ) .. "/class_pointset.lua" ) +dofile( minetest.get_modpath( "digtron" ) .. "/class_layout.lua" ) dofile( minetest.get_modpath( "digtron" ) .. "/entities.lua" ) dofile( minetest.get_modpath( "digtron" ) .. "/node_misc.lua" ) -- contains structure and light nodes dofile( minetest.get_modpath( "digtron" ) .. "/node_storage.lua" ) -- contains inventory and fuel storage nodes diff --git a/pointset.lua b/pointset.lua deleted file mode 100644 index 5bfd22a..0000000 --- a/pointset.lua +++ /dev/null @@ -1,73 +0,0 @@ --- A simple special-purpose class, this is used for building up sets of three-dimensional points --- I only added features to it as I needed them so may not be highly useful outside of this mod's context. - -Pointset = {} -Pointset.__index = Pointset - -function Pointset.create() - local set = {} - setmetatable(set,Pointset) - set.points = {} - return set -end - -function Pointset:set(x, y, z, value) - -- sets a value in the 3D array "points". - if self.points[x] == nil then - self.points[x] = {} - end - if self.points[x][y] == nil then - self.points[x][y] = {} - end - self.points[x][y][z] = value -end - -function Pointset:set_if_not_in(excluded, x, y, z, value) - -- If a value is not already set for this point in the 3D array "excluded", set it in "points" - if excluded:get(x, y, z) ~= nil then - return - end - self:set(x, y, z, value) -end - -function Pointset:get(x, y, z) - -- return a value from the 3D array "points" - if self.points[x] == nil or self.points[x][y] == nil then - return nil - end - return self.points[x][y][z] -end - -function Pointset:pop() - -- returns a point that's in the 3D array, and then removes it. - local pos = {} - local ytable - local ztable - local val - - local count = 0 - for _ in pairs(self.points) do count = count + 1 end - if count == 0 then - return nil - end - - pos.x, ytable = next(self.points) - pos.y, ztable = next(ytable) - pos.z, val = next(ztable) - - self.points[pos.x][pos.y][pos.z] = nil - - count = 0 - for _ in pairs(self.points[pos.x][pos.y]) do count = count + 1 end - if count == 0 then - self.points[pos.x][pos.y] = nil - end - - count = 0 - for _ in pairs(self.points[pos.x]) do count = count + 1 end - if count == 0 then - self.points[pos.x] = nil - end - - return pos, val -end \ No newline at end of file diff --git a/util.lua b/util.lua index 73d6d22..acebc59 100644 --- a/util.lua +++ b/util.lua @@ -4,7 +4,6 @@ digtron = {} dofile( minetest.get_modpath( "digtron" ) .. "/util_item_place_node.lua" ) -- separated out to avoid potential for license complexity dofile( minetest.get_modpath( "digtron" ) .. "/util_movement.lua" ) -- separated out simply for tidiness, there's some big code in there -dofile( minetest.get_modpath( "digtron" ) .. "/util_layout.lua" ) -- separated out simply for tidiness, there's some big code in there dofile( minetest.get_modpath( "digtron" ) .. "/util_execute_cycle.lua" ) -- separated out simply for tidiness, there's some big code in there -- Apparently node_sound_metal_defaults is a newer thing, I ran into games using an older version of the default mod without it. diff --git a/util_layout.lua b/util_layout.lua deleted file mode 100644 index b7311c5..0000000 --- a/util_layout.lua +++ /dev/null @@ -1,345 +0,0 @@ -DigtronLayout = {} -DigtronLayout.__index = DigtronLayout - -------------------------------------------------------------------------- --- Creation - -local get_node_image = function(pos, node) - local node_image = {node=node, pos={x=pos.x, y=pos.y, z=pos.z}} - node_image.paramtype2 = minetest.registered_nodes[node.name].paramtype2 - local meta = minetest.get_meta(pos) - node_image.meta = meta:to_table() - - -- Record what kind of thing we've got in a builder node so its facing can be rotated properly - if minetest.get_item_group(node.name, "digtron") == 4 then - local build_item = node_image.meta.inventory.main[1] - if build_item ~= "" then - local build_item_def = minetest.registered_nodes[ItemStack(build_item):get_name()] - node_image.build_item_paramtype2 = build_item_def.paramtype2 - end - end - return node_image -end - -function DigtronLayout.create(pos, player) - local self = {} - setmetatable(self,DigtronLayout) - - --initialize. We're assuming that the start position is a controller digtron, should be a safe assumption since only the controller node should call this - self.traction = 0 - self.all = {} - self.inventories = {} - self.fuelstores = {} - self.diggers = {} - self.builders = {} - self.extents = {} - self.water_touching = false - self.lava_touching = false - self.protected = Pointset.create() -- if any nodes we look at are protected, make note of that. That way we don't need to keep re-testing protection state later. - self.old_pos_pointset = Pointset.create() -- For tracking original location of nodes if we do transformations on the Digtron - self.nodes_dug = Pointset.create() -- For tracking adjacent nodes that will have been dug by digger heads in future - self.contains_protected_node = false -- used to indicate if at least one node in this digtron array is protected from the player. - self.controller = {x=pos.x, y=pos.y, z=pos.z} --Make a deep copy of the pos parameter just in case the calling code wants to play silly buggers with it - - table.insert(self.all, get_node_image(pos, minetest.get_node(pos))) -- We never visit the source node, so insert it into the all table a priori. Revisit this if a controller node is created that contains fuel or inventory or whatever. - - self.extents.max_x = pos.x - self.extents.min_x = pos.x - self.extents.max_y = pos.y - self.extents.min_y = pos.y - self.extents.max_z = pos.z - self.extents.min_z = pos.z - - -- temporary pointsets used while searching - local to_test = Pointset.create() - local tested = Pointset.create() - - tested:set(pos.x, pos.y, pos.z, true) - to_test:set(pos.x + 1, pos.y, pos.z, true) - to_test:set(pos.x - 1, pos.y, pos.z, true) - to_test:set(pos.x, pos.y + 1, pos.z, true) - to_test:set(pos.x, pos.y - 1, pos.z, true) - to_test:set(pos.x, pos.y, pos.z + 1, true) - to_test:set(pos.x, pos.y, pos.z - 1, true) - - if minetest.is_protected(pos, player:get_player_name()) and not minetest.check_player_privs(player, "protection_bypass") then - self.protected:set(pos.x, pos.y, pos.z, true) - self.contains_protected_node = true - end - - -- Do a loop on to_test positions, adding new to_test positions as we find digtron nodes. This is a flood fill operation - -- that follows node faces (no diagonals) - local testpos, _ = to_test:pop() - while testpos ~= nil do - tested:set(testpos.x, testpos.y, testpos.z, true) -- track nodes we've looked at to prevent infinite loops - local node = minetest.get_node(testpos) - - if node.name == "ignore" then - --buildtron array is next to unloaded nodes, too dangerous to do anything. Abort. - return nil - end - - if minetest.get_item_group(node.name, "water") ~= 0 then - self.water_touching = true - elseif minetest.get_item_group(node.name, "lava") ~= 0 then - self.lava_touching = true - if digtron.lava_impassible == true then - self.protected:set(testpos.x, testpos.y, testpos.z, true) - end - end - - local group_number = minetest.get_item_group(node.name, "digtron") - if group_number > 0 then - --found one. Add it to the digtrons output - local node_image = get_node_image(testpos, node) - - table.insert(self.all, node_image) - - -- add a reference to this node's position to special node lists - if group_number == 2 then - table.insert(self.inventories, node_image) - elseif group_number == 3 then - table.insert(self.diggers, node_image) - elseif group_number == 4 then - table.insert(self.builders, node_image) - elseif group_number == 5 then - table.insert(self.fuelstores, node_image) - elseif group_number == 6 then - table.insert(self.inventories, node_image) - table.insert(self.fuelstores, node_image) - end - - if minetest.is_protected(pos, player:get_player_name()) and not minetest.check_player_privs(player, "protection_bypass") then - self.contains_protected_node = true - end - - -- update extents - self.extents.max_x = math.max(self.extents.max_x, testpos.x) - self.extents.min_x = math.min(self.extents.min_x, testpos.x) - self.extents.max_y = math.max(self.extents.max_y, testpos.y) - self.extents.min_y = math.min(self.extents.min_y, testpos.y) - self.extents.max_z = math.max(self.extents.max_z, testpos.z) - self.extents.min_z = math.min(self.extents.min_z, testpos.z) - - --queue up potential new test points adjacent to this digtron node - to_test:set_if_not_in(tested, testpos.x + 1, testpos.y, testpos.z, true) - to_test:set_if_not_in(tested, testpos.x - 1, testpos.y, testpos.z, true) - to_test:set_if_not_in(tested, testpos.x, testpos.y + 1, testpos.z, true) - to_test:set_if_not_in(tested, testpos.x, testpos.y - 1, testpos.z, true) - to_test:set_if_not_in(tested, testpos.x, testpos.y, testpos.z + 1, true) - to_test:set_if_not_in(tested, testpos.x, testpos.y, testpos.z - 1, true) - elseif minetest.registered_nodes[node.name].buildable_to ~= true then - -- Tracks whether the digtron is hovering in mid-air. If any part of the digtron array touches something solid it gains traction. - self.traction = self.traction + 1 - end - - testpos, _ = to_test:pop() - end - - return self -end - ------------------------------------------------------------------------- --- Rotation - -local facedir_rotate = { - ['x'] = { - [-1] = {[0]=4, 5, 6, 7, 22, 23, 20, 21, 0, 1, 2, 3, 13, 14, 15, 12, 19, 16, 17, 18, 10, 11, 8, 9}, -- 270 degrees - [1] = {[0]=8, 9, 10, 11, 0, 1, 2, 3, 22, 23, 20, 21, 15, 12, 13, 14, 17, 18, 19, 16, 6, 7, 4, 5}, -- 90 degrees - }, - ['y'] = { - [-1] = {[0]=3, 0, 1, 2, 19, 16, 17, 18, 15, 12, 13, 14, 7, 4, 5, 6, 11, 8, 9, 10, 21, 22, 23, 20}, -- 270 degrees - [1] = {[0]=1, 2, 3, 0, 13, 14, 15, 12, 17, 18, 19, 16, 9, 10, 11, 8, 5, 6, 7, 4, 23, 20, 21, 22}, -- 90 degrees - }, - ['z'] = { - [-1] = {[0]=16, 17, 18, 19, 5, 6, 7, 4, 11, 8, 9, 10, 0, 1, 2, 3, 20, 21, 22, 23, 12, 13, 14, 15}, -- 270 degrees - [1] = {[0]=12, 13, 14, 15, 7, 4, 5, 6, 9, 10, 11, 8, 20, 21, 22, 23, 0, 1, 2, 3, 16, 17, 18, 19}, -- 90 degrees - } -} - -local wallmounted_rotate = { - ['x'] = { - [-1] = {[0]=4, 5, 2, 3, 1, 0}, -- 270 degrees - [1] = {[0]=5, 4, 2, 3, 0, 1}, -- 90 degrees - }, - ['y'] = { - [-1] = {[0]=0, 1, 4, 5, 3, 2}, -- 270 degrees - [1] = {[0]=0, 1, 5, 4, 2, 3}, -- 90 degrees - }, - ['z'] = { - [-1] = {[0]=3, 2, 0, 1, 4, 5}, -- 270 degrees - [1] = {[0]=2, 3, 1, 0, 4, 5}, -- 90 degrees - } -} - - --90 degrees CW about x-axis: (x, y, z) -> (x, -z, y) - --90 degrees CCW about x-axis: (x, y, z) -> (x, z, -y) - --90 degrees CW about y-axis: (x, y, z) -> (-z, y, x) - --90 degrees CCW about y-axis: (x, y, z) -> (z, y, -x) - --90 degrees CW about z-axis: (x, y, z) -> (y, -x, z) - --90 degrees CCW about z-axis: (x, y, z) -> (-y, x, z) -local rotate_pos = function(axis, direction, pos) - if axis == "x" then - if direction < 0 then - return {x= pos.x, y= -pos.z, z= pos.y} - else - return {x= pos.x, y= pos.z, z= -pos.y} - end - elseif axis == "y" then - if direction < 0 then - return {x= -pos.z, y= pos.y, z= pos.x} - else - return {x= pos.z, y= pos.y, z= -pos.x} - end - else - if direction < 0 then - return {x= -pos.y, y= pos.x, z= pos.z} - else - return {x= pos.y, y= -pos.x, z= pos.z} - end - end -end - -local rotate_node_image = function(node_image, origin, axis, direction, old_pos_pointset) - -- Facings - if node_image.paramtype2 == "wallmounted" then - node_image.node.param2 = wallmounted_rotate[axis][direction][node_image.node.param2] - elseif node_image.paramtype2 == "facedir" then - node_image.node.param2 = facedir_rotate[axis][direction][node_image.node.param2] - end - - if node_image.build_item_paramtype2 == "wallmounted" then - node_image.meta.fields.build_facing = wallmounted_rotate[axis][direction][tonumber(node_image.meta.fields.build_facing)] - elseif node_image.build_item_paramtype2 == "facedir" then - node_image.meta.fields.build_facing = facedir_rotate[axis][direction][tonumber(node_image.meta.fields.build_facing)] - end - - node_image.meta.fields.waiting = nil -- If we're rotating a controller that's in the "waiting" state, clear it. Otherwise it may stick like that. - - -- record the old location so we can destroy the old node if the rotation operation is possible - old_pos_pointset:set(node_image.pos.x, node_image.pos.y, node_image.pos.z, true) - - -- position in space relative to origin - local pos = vector.subtract(node_image.pos, origin) - pos = rotate_pos(axis, direction, pos) - -- Move back to original reference frame - node_image.pos = vector.add(pos, origin) - - return node_image -end - --- Rotates 90 degrees widdershins around the axis defined by facedir (which in this case is pointing out the front of the node, so it needs to be converted into an upward-pointing axis internally) -function DigtronLayout.rotate_layout_image(self, facedir) - -- To convert this into the direction the "top" of the axel node is pointing in: - -- 0, 1, 2, 3 == (0,1,0) - -- 4, 5, 6, 7 == (0,0,1) - -- 8, 9, 10, 11 == (0,0,-1) - -- 12, 13, 14, 15 == (1,0,0) - -- 16, 17, 18, 19 == (-1,0,0) - -- 20, 21, 22, 23== (0,-1,0) - - local top = { - [0]={axis="y", dir=-1}, - {axis="z", dir=1}, - {axis="z", dir=-1}, - {axis="x", dir=1}, - {axis="x", dir=-1}, - {axis="y", dir=1}, - } - local params = top[math.floor(facedir/4)] - - for k, node_image in pairs(self.all) do - rotate_node_image(node_image, self.controller, params.axis, params.dir, self.old_pos_pointset) - end - return self -end - ------------------------------------------------------------------------------------------------ --- Translation - -function DigtronLayout.move_layout_image(self, facing, player_name) - local extents = self.extents - local dir = digtron.facedir_to_dir_map[facing] - local increment - local filter - if dir == 1 then -- z+ - filter = "z" - increment = 1 - extents.max_z = extents.max_z + 1 - extents.min_z = extents.min_z + 1 - elseif dir == 2 then -- x+ - filter = "x" - increment = 1 - extents.max_x = extents.max_x + 1 - extents.min_x = extents.min_x + 1 - elseif dir == 3 then -- z- - filter = "z" - increment = -1 - extents.max_z = extents.max_z - 1 - extents.min_z = extents.min_z - 1 - elseif dir == 4 then -- x- - filter = "x" - increment = -1 - extents.max_x = extents.max_x - 1 - extents.min_x = extents.min_x - 1 - elseif dir == 5 then -- y- - filter = "y" - increment = -1 - extents.max_y = extents.max_y - 1 - extents.min_y = extents.min_y - 1 - elseif dir == 6 then -- y+ - filter = "y" - increment = 1 - extents.max_y = extents.max_y + 1 - extents.min_y = extents.min_y + 1 - end - - for k, node_image in pairs(self.all) do - self.old_pos_pointset:set(node_image.pos.x, node_image.pos.y, node_image.pos.z, true) - node_image.pos[filter] = node_image.pos[filter] + increment - self.nodes_dug:set(node_image.pos.x, node_image.pos.y, node_image.pos.z, false) -- we've moved a digtron node into this space, mark it so that we don't dig it. - -- TODO: log - end -end - ------------------------------------------------------------------------------------------------ --- Writing to world - -function DigtronLayout.can_write_layout_image(self) - for k, node_image in pairs(self.all) do - -- check if the target node is buildable_to or is marked as part of the digtron that's moving - if not self.old_pos_pointset:get(node_image.pos.x, node_image.pos.y, node_image.pos.z) - and not minetest.registered_nodes[minetest.get_node(node_image.pos).name].buildable_to then - return false - --check if we're moving into a protected node - elseif self.protected:get(node_image.pos) then - return false - end - end - return true -end - -function DigtronLayout.write_layout_image(self) - -- destroy the old digtron - local oldpos, _ = self.old_pos_pointset:pop() - while oldpos ~= nil do - local old_def = minetest.registered_nodes[minetest.get_node(oldpos).name] - minetest.remove_node(oldpos) - if old_def.after_dig_node ~= nil then - old_def.after_dig_node(oldpos) - end - oldpos, _ = self.old_pos_pointset:pop() - end - - -- create the new one - for k, node_image in pairs(self.all) do - minetest.add_node(node_image.pos, node_image.node) - minetest.get_meta(node_image.pos):from_table(node_image.meta) - - local new_def = minetest.registered_nodes[node_image.node.name] - if new_def.after_place_node ~= nil then - new_def.after_place_node(node_image.pos) - end - end -end - -- cgit v1.2.3