Merge pull request #1 from FaceDeer/layout-refactor

Layout refactor
This commit is contained in:
FaceDeer 2017-01-12 00:53:04 -07:00 committed by GitHub
commit 578484352b
9 changed files with 191 additions and 310 deletions

@ -1,27 +1,56 @@
digtron.get_all_digtron_neighbours = function(pos, player) DigtronLayout = {}
-- returns table containing a list of all digtron node locations, lists of special digtron node types, a table of the coordinate extents of the digtron array, a Pointset of protected nodes, and a number to determine how many adjacent solid non-digtron nodes there are (for traction) 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()]
if build_item_def ~= nil then
node_image.build_item_paramtype2 = build_item_def.paramtype2
end
end
end
return node_image
end
function DigtronLayout.create(pos, player)
local self = {}
setmetatable(self,DigtronLayout)
local layout = {}
--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 --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
layout.traction = 0 self.traction = 0
layout.all = {} self.all = {}
layout.inventories = {} self.inventories = {}
layout.fuelstores = {} self.fuelstores = {}
layout.diggers = {} self.diggers = {}
layout.builders = {} self.builders = {}
layout.extents = {} self.extents = {}
layout.water_touching = false self.water_touching = false
layout.lava_touching = false self.lava_touching = false
layout.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.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.
layout.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 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(layout.all, layout.controller) 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.
layout.extents.max_x = pos.x
layout.extents.min_x = pos.x self.extents.max_x = pos.x
layout.extents.max_y = pos.y self.extents.min_x = pos.x
layout.extents.min_y = pos.y self.extents.max_y = pos.y
layout.extents.max_z = pos.z self.extents.min_y = pos.y
layout.extents.min_z = pos.z self.extents.max_z = pos.z
self.extents.min_z = pos.z
-- temporary pointsets used while searching -- temporary pointsets used while searching
local to_test = Pointset.create() local to_test = Pointset.create()
@ -36,7 +65,8 @@ digtron.get_all_digtron_neighbours = function(pos, player)
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 if minetest.is_protected(pos, player:get_player_name()) and not minetest.check_player_privs(player, "protection_bypass") then
layout.protected:set(pos.x, pos.y, pos.z, true) self.protected:set(pos.x, pos.y, pos.z, true)
self.contains_protected_node = true
end end
-- Do a loop on to_test positions, adding new to_test positions as we find digtron nodes. This is a flood fill operation -- Do a loop on to_test positions, adding new to_test positions as we find digtron nodes. This is a flood fill operation
@ -48,50 +78,51 @@ digtron.get_all_digtron_neighbours = function(pos, player)
if node.name == "ignore" then if node.name == "ignore" then
--buildtron array is next to unloaded nodes, too dangerous to do anything. Abort. --buildtron array is next to unloaded nodes, too dangerous to do anything. Abort.
layout.all = nil return nil
return layout
end
if minetest.is_protected(pos, player:get_player_name()) and not minetest.check_player_privs(player, "protection_bypass") then
layout.protected:set(testpos.x, testpos.y, testpos.z, true)
end end
if minetest.get_item_group(node.name, "water") ~= 0 then if minetest.get_item_group(node.name, "water") ~= 0 then
layout.water_touching = true self.water_touching = true
elseif minetest.get_item_group(node.name, "lava") ~= 0 then elseif minetest.get_item_group(node.name, "lava") ~= 0 then
layout.lava_touching = true self.lava_touching = true
if digtron.lava_impassible == true then if digtron.lava_impassible == true then
layout.protected:set(testpos.x, testpos.y, testpos.z, true) self.protected:set(testpos.x, testpos.y, testpos.z, true)
end end
end end
local group_number = minetest.get_item_group(node.name, "digtron") local group_number = minetest.get_item_group(node.name, "digtron")
if group_number > 0 then if group_number > 0 then
--found one. Add it to the digtrons output --found one. Add it to the digtrons output
table.insert(layout.all, testpos) local node_image = get_node_image(testpos, node)
-- update extents table.insert(self.all, node_image)
layout.extents.max_x = math.max(layout.extents.max_x, testpos.x)
layout.extents.min_x = math.min(layout.extents.min_x, testpos.x)
layout.extents.max_y = math.max(layout.extents.max_y, testpos.y)
layout.extents.min_y = math.min(layout.extents.min_y, testpos.y)
layout.extents.max_z = math.max(layout.extents.max_z, testpos.z)
layout.extents.min_z = math.min(layout.extents.min_z, testpos.z)
-- add a reference to this node's position to special node lists -- add a reference to this node's position to special node lists
if group_number == 2 then if group_number == 2 then
table.insert(layout.inventories, testpos) table.insert(self.inventories, node_image)
elseif group_number == 3 then elseif group_number == 3 then
table.insert(layout.diggers, testpos) table.insert(self.diggers, node_image)
elseif group_number == 4 then elseif group_number == 4 then
table.insert(layout.builders, testpos) table.insert(self.builders, node_image)
elseif group_number == 5 then elseif group_number == 5 then
table.insert(layout.fuelstores, testpos) table.insert(self.fuelstores, node_image)
elseif group_number == 6 then elseif group_number == 6 then
table.insert(layout.inventories, testpos) table.insert(self.inventories, node_image)
table.insert(layout.fuelstores, testpos) table.insert(self.fuelstores, node_image)
end 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 --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 - 1, testpos.y, testpos.z, true) to_test:set_if_not_in(tested, testpos.x - 1, testpos.y, testpos.z, true)
@ -101,17 +132,17 @@ digtron.get_all_digtron_neighbours = function(pos, player)
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 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. -- Tracks whether the digtron is hovering in mid-air. If any part of the digtron array touches something solid it gains traction.
layout.traction = layout.traction + 1 self.traction = self.traction + 1
end end
testpos, _ = to_test:pop() testpos, _ = to_test:pop()
end end
return layout return self
end end
-- Rotation magic ------------------------------------------------------------------------
-------------------------------------------------------------------------------------------------------- -- Rotation
local facedir_rotate = { local facedir_rotate = {
['x'] = { ['x'] = {
@ -171,23 +202,6 @@ local rotate_pos = function(axis, direction, pos)
end end
end end
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
local rotate_node_image = function(node_image, origin, axis, direction, old_pos_pointset) local rotate_node_image = function(node_image, origin, axis, direction, old_pos_pointset)
-- Facings -- Facings
if node_image.paramtype2 == "wallmounted" then if node_image.paramtype2 == "wallmounted" then
@ -216,7 +230,8 @@ local rotate_node_image = function(node_image, origin, axis, direction, old_pos_
return node_image return node_image
end end
digtron.rotate_layout_image = function(layout_image, facedir) -- 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: -- To convert this into the direction the "top" of the axel node is pointing in:
-- 0, 1, 2, 3 == (0,1,0) -- 0, 1, 2, 3 == (0,1,0)
-- 4, 5, 6, 7 == (0,0,1) -- 4, 5, 6, 7 == (0,0,1)
@ -235,40 +250,91 @@ digtron.rotate_layout_image = function(layout_image, facedir)
} }
local params = top[math.floor(facedir/4)] local params = top[math.floor(facedir/4)]
layout_image.old_pos_pointset = Pointset:create() for k, node_image in pairs(self.all) do
rotate_node_image(node_image, self.controller, params.axis, params.dir, self.old_pos_pointset)
for k, node_image in pairs(layout_image.all) do
rotate_node_image(node_image, layout_image.controller, params.axis, params.dir, layout_image.old_pos_pointset)
end end
return layout_image return self
end end
digtron.can_write_layout_image = function(layout_image, player) -----------------------------------------------------------------------------------------------
for k, node_image in pairs(layout_image.all) do -- Translation
if not layout_image.old_pos_pointset:get(node_image.pos.x, node_image.pos.y, node_image.pos.z)
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 and not minetest.registered_nodes[minetest.get_node(node_image.pos).name].buildable_to then
return false return false
elseif minetest.is_protected(node_image.pos, player:get_player_name()) and not minetest.check_player_privs(player, "protection_bypass") then --check if we're moving into a protected node
elseif self.protected:get(node_image.pos) then
return false return false
end end
end end
return true return true
end end
digtron.write_layout_image = function(layout_image) function DigtronLayout.write_layout_image(self)
-- destroy the old digtron -- destroy the old digtron
local oldpos, _ = layout_image.old_pos_pointset:pop() local oldpos, _ = self.old_pos_pointset:pop()
while oldpos ~= nil do while oldpos ~= nil do
local old_def = minetest.registered_nodes[minetest.get_node(oldpos).name] local old_def = minetest.registered_nodes[minetest.get_node(oldpos).name]
minetest.remove_node(oldpos) minetest.remove_node(oldpos)
if old_def.after_dig_node ~= nil then if old_def.after_dig_node ~= nil then
old_def.after_dig_node(oldpos) old_def.after_dig_node(oldpos)
end end
oldpos, _ = layout_image.old_pos_pointset:pop() oldpos, _ = self.old_pos_pointset:pop()
end end
-- create the new one -- create the new one
for k, node_image in pairs(layout_image.all) do for k, node_image in pairs(self.all) do
minetest.add_node(node_image.pos, node_image.node) minetest.add_node(node_image.pos, node_image.node)
minetest.get_meta(node_image.pos):from_table(node_image.meta) minetest.get_meta(node_image.pos):from_table(node_image.meta)
@ -279,81 +345,3 @@ digtron.write_layout_image = function(layout_image)
end end
end end
-- Similar to get_layout, but far more comprehensive. This produces a data structure plus a set of temporary inventories that will allow the digtron to be rotated and then recreated.
digtron.get_layout_image = function(pos, player)
local image = {}
--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
image.all = {}
image.extents = {}
image.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
image.contains_protected_node = false -- used to indicate if at least one node in this digtron array is protected from the player.
table.insert(image.all, get_node_image(pos, minetest.get_node(pos)))
image.extents.max_x = pos.x
image.extents.min_x = pos.x
image.extents.max_y = pos.y
image.extents.min_y = pos.y
image.extents.max_z = pos.z
image.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
image.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
local group_number = minetest.get_item_group(node.name, "digtron")
if group_number > 0 then
--found one. Add it to the digtrons output
table.insert(image.all, get_node_image(testpos, node))
if minetest.is_protected(pos, player:get_player_name()) and not minetest.check_player_privs(player, "protection_bypass") then
image.contains_protected_node = true
end
-- update extents
image.extents.max_x = math.max(image.extents.max_x, testpos.x)
image.extents.min_x = math.min(image.extents.min_x, testpos.x)
image.extents.max_y = math.max(image.extents.max_y, testpos.y)
image.extents.min_y = math.min(image.extents.min_y, testpos.y)
image.extents.max_z = math.max(image.extents.max_z, testpos.z)
image.extents.min_z = math.min(image.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)
end
testpos, _ = to_test:pop()
end
return image
end

@ -1,5 +1,6 @@
dofile( minetest.get_modpath( "digtron" ) .. "/util.lua" ) 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" ) .. "/entities.lua" )
dofile( minetest.get_modpath( "digtron" ) .. "/node_misc.lua" ) -- contains structure and light nodes 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 dofile( minetest.get_modpath( "digtron" ) .. "/node_storage.lua" ) -- contains inventory and fuel storage nodes

@ -36,10 +36,10 @@ minetest.register_node("digtron:axle", {
-- Been too soon since last time the digtron rotated. -- Been too soon since last time the digtron rotated.
return return
end end
local image = digtron.get_layout_image(pos, clicker) local image = DigtronLayout.create(pos, clicker)
digtron.rotate_layout_image(image, node.param2) image:rotate_layout_image(node.param2)
if digtron.can_write_layout_image(image, clicker) then if image:can_write_layout_image() then
digtron.write_layout_image(image) image:write_layout_image()
minetest.sound_play("whirr", {gain=1.0, pos=pos}) minetest.sound_play("whirr", {gain=1.0, pos=pos})
meta = minetest.get_meta(pos) meta = minetest.get_meta(pos)

@ -223,6 +223,7 @@ minetest.register_node("digtron:pusher", {
end end
local newpos, status_text, return_code = digtron.execute_move_cycle(pos, clicker) local newpos, status_text, return_code = digtron.execute_move_cycle(pos, clicker)
meta = minetest.get_meta(newpos)
meta:set_string("infotext", status_text) meta:set_string("infotext", status_text)
-- Start the delay before digtron can run again. -- Start the delay before digtron can run again.

Binary file not shown.

Before

Width:  |  Height:  |  Size: 783 B

After

Width:  |  Height:  |  Size: 835 B

@ -3,8 +3,6 @@
digtron = {} 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_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 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. -- Apparently node_sound_metal_defaults is a newer thing, I ran into games using an older version of the default mod without it.
@ -103,7 +101,7 @@ digtron.place_in_inventory = function(itemname, inventory_positions, fallback_po
--tries placing the item in each inventory node in turn. If there's no room, drop it at fallback_pos --tries placing the item in each inventory node in turn. If there's no room, drop it at fallback_pos
local itemstack = ItemStack(itemname) local itemstack = ItemStack(itemname)
for k, location in pairs(inventory_positions) do for k, location in pairs(inventory_positions) do
local inv = minetest.get_inventory({type="node", pos=location}) local inv = minetest.get_inventory({type="node", pos=location.pos})
itemstack = inv:add_item("main", itemstack) itemstack = inv:add_item("main", itemstack)
if itemstack:is_empty() then if itemstack:is_empty() then
return nil return nil
@ -131,10 +129,10 @@ digtron.take_from_inventory = function(itemname, inventory_positions)
--tries to take an item from each inventory node in turn. Returns location of inventory item was taken from on success, nil on failure --tries to take an item from each inventory node in turn. Returns location of inventory item was taken from on success, nil on failure
local itemstack = ItemStack(itemname) local itemstack = ItemStack(itemname)
for k, location in pairs(inventory_positions) do for k, location in pairs(inventory_positions) do
local inv = minetest.get_inventory({type="node", pos=location}) local inv = minetest.get_inventory({type="node", pos=location.pos})
local output = inv:remove_item("main", itemstack) local output = inv:remove_item("main", itemstack)
if not output:is_empty() then if not output:is_empty() then
return location return location.pos
end end
end end
return nil return nil
@ -162,7 +160,7 @@ digtron.burn = function(fuelstore_positions, target, test)
if current_burned > target then if current_burned > target then
break break
end end
local inv = minetest.get_inventory({type="node", pos=location}) local inv = minetest.get_inventory({type="node", pos=location.pos})
local invlist = inv:get_list("fuel") local invlist = inv:get_list("fuel")
for i, itemstack in pairs(invlist) do for i, itemstack in pairs(invlist) do
local fuel_per_item = minetest.get_craft_result({method="fuel", width=1, items={itemstack:peek_item(1)}}).time local fuel_per_item = minetest.get_craft_result({method="fuel", width=1, items={itemstack:peek_item(1)}}).time

@ -90,7 +90,7 @@ digtron.execute_dig_cycle = function(pos, clicker)
local fuel_burning = meta:get_float("fuel_burning") -- get amount of burned fuel left over from last cycle local fuel_burning = meta:get_float("fuel_burning") -- get amount of burned fuel left over from last cycle
local status_text = string.format("Heat remaining in controller furnace: %d", fuel_burning) local status_text = string.format("Heat remaining in controller furnace: %d", fuel_burning)
local layout = digtron.get_all_digtron_neighbours(pos, clicker) local layout = DigtronLayout.create(pos, clicker)
local status_text, return_code = neighbour_test(layout, status_text) local status_text, return_code = neighbour_test(layout, status_text)
if return_code ~= 0 then if return_code ~= 0 then
@ -103,7 +103,6 @@ digtron.execute_dig_cycle = function(pos, clicker)
---------------------------------------------------------------------------------------------------------------------- ----------------------------------------------------------------------------------------------------------------------
local nodes_dug = Pointset.create()
local items_dropped = {} local items_dropped = {}
local digging_fuel_cost = 0 local digging_fuel_cost = 0
local particle_systems = {} local particle_systems = {}
@ -113,16 +112,16 @@ digtron.execute_dig_cycle = function(pos, clicker)
-- but doesn't actually dig the nodes yet. That comes later. -- but doesn't actually dig the nodes yet. That comes later.
-- If we dug them now, sand would fall and some digtron nodes would die. -- If we dug them now, sand would fall and some digtron nodes would die.
for k, location in pairs(layout.diggers) do for k, location in pairs(layout.diggers) do
local target = minetest.get_node(location) local target = minetest.get_node(location.pos)
local targetdef = minetest.registered_nodes[target.name] local targetdef = minetest.registered_nodes[target.name]
if targetdef.execute_dig ~= nil then if targetdef.execute_dig ~= nil then
local fuel_cost, dropped = targetdef.execute_dig(location, layout.protected, nodes_dug, controlling_coordinate) local fuel_cost, dropped = targetdef.execute_dig(location.pos, layout.protected, layout.nodes_dug, controlling_coordinate)
if dropped ~= nil then if dropped ~= nil then
for _, itemname in pairs(dropped) do for _, itemname in pairs(dropped) do
table.insert(items_dropped, itemname) table.insert(items_dropped, itemname)
end end
if digtron.particle_effects then if digtron.particle_effects then
table.insert(particle_systems, dig_dust(vector.add(location, move_dir), target.param2)) table.insert(particle_systems, dig_dust(vector.add(location.pos, move_dir), target.param2))
end end
end end
digging_fuel_cost = digging_fuel_cost + fuel_cost digging_fuel_cost = digging_fuel_cost + fuel_cost
@ -137,8 +136,8 @@ digtron.execute_dig_cycle = function(pos, clicker)
-- as having been dug. -- as having been dug.
local can_move = true local can_move = true
for _, location in pairs(layout.all) do for _, location in pairs(layout.all) do
local newpos = digtron.find_new_pos(location, facing) local newpos = digtron.find_new_pos(location.pos, facing)
if not digtron.can_move_to(newpos, layout.protected, nodes_dug) then if not digtron.can_move_to(newpos, layout.protected, layout.nodes_dug) then
can_move = false can_move = false
end end
end end
@ -165,11 +164,11 @@ digtron.execute_dig_cycle = function(pos, clicker)
local test_fuel_items = {} local test_fuel_items = {}
local test_build_fuel_cost = 0 local test_build_fuel_cost = 0
for k, location in pairs(layout.builders) do for k, location in pairs(layout.builders) do
local target = minetest.get_node(location) local target = minetest.get_node(location.pos)
local targetdef = minetest.registered_nodes[target.name] local targetdef = minetest.registered_nodes[target.name]
local test_location = digtron.find_new_pos(location, facing) local test_location = digtron.find_new_pos(location.pos, facing)
if targetdef.test_build ~= nil then if targetdef.test_build ~= nil then
test_build_return_code, test_build_return_item = targetdef.test_build(location, test_location, layout.inventories, layout.protected, nodes_dug, controlling_coordinate, layout.controller) test_build_return_code, test_build_return_item = targetdef.test_build(location.pos, test_location, layout.inventories, layout.protected, layout.nodes_dug, controlling_coordinate, layout.controller)
if test_build_return_code > 1 then if test_build_return_code > 1 then
can_build = false can_build = false
break break
@ -222,27 +221,23 @@ digtron.execute_dig_cycle = function(pos, clicker)
-- All tests passed, ready to go for real! -- All tests passed, ready to go for real!
minetest.sound_play("construction", {gain=1.0, pos=pos}) minetest.sound_play("construction", {gain=1.0, pos=pos})
-- store or drop the products of the digger heads
for _, itemname in pairs(items_dropped) do
digtron.place_in_inventory(itemname, layout.inventories, pos)
end
-- if the player is standing within the array or next to it, move him too. -- if the player is standing within the array or next to it, move him too.
local move_player = move_player_test(layout, clicker) local move_player = move_player_test(layout, clicker)
-- damage the weak flesh -- damage the weak flesh
if digtron.diggers_damage_creatures then if digtron.diggers_damage_creatures then
for k, location in pairs(layout.diggers) do for k, location in pairs(layout.diggers) do
local target = minetest.get_node(location) local target = minetest.get_node(location.pos)
local targetdef = minetest.registered_nodes[target.name] local targetdef = minetest.registered_nodes[target.name]
if targetdef.damage_creatures ~= nil then if targetdef.damage_creatures ~= nil then
targetdef.damage_creatures(clicker, location, digtron.find_new_pos(location, target.param2), controlling_coordinate) targetdef.damage_creatures(clicker, location.pos, digtron.find_new_pos(location.pos, target.param2), controlling_coordinate)
end end
end end
end end
--move the array --move the array
digtron.move_digtron(facing, layout.all, layout.extents, nodes_dug, clicker:get_player_name()) layout:move_layout_image(facing, clicker:get_player_name())
layout:write_layout_image()
local oldpos = {x=pos.x, y=pos.y, z=pos.z} local oldpos = {x=pos.x, y=pos.y, z=pos.z}
pos = digtron.find_new_pos(pos, facing) pos = digtron.find_new_pos(pos, facing)
meta = minetest.get_meta(pos) meta = minetest.get_meta(pos)
@ -250,15 +245,21 @@ digtron.execute_dig_cycle = function(pos, clicker)
clicker:moveto(digtron.find_new_pos(clicker:getpos(), facing), true) clicker:moveto(digtron.find_new_pos(clicker:getpos(), facing), true)
end end
-- store or drop the products of the digger heads
for _, itemname in pairs(items_dropped) do
minetest.debug("placing in inventory", itemname)
digtron.place_in_inventory(itemname, layout.inventories, oldpos)
end
local building_fuel_cost = 0 local building_fuel_cost = 0
local strange_failure = false local strange_failure = false
-- execute_build on all digtron components that have one -- execute_build on all digtron components that have one
for k, location in pairs(layout.builders) do for k, location in pairs(layout.builders) do
local target = minetest.get_node(location) local target = minetest.get_node(location.pos)
local targetdef = minetest.registered_nodes[target.name] local targetdef = minetest.registered_nodes[target.name]
if targetdef.execute_build ~= nil then if targetdef.execute_build ~= nil then
--using the old location of the controller as fallback so that any leftovers land with the rest of the digger output. Not that there should be any. --using the old location of the controller as fallback so that any leftovers land with the rest of the digger output. Not that there should be any.
local build_return = targetdef.execute_build(location, clicker, layout.inventories, layout.protected, nodes_dug, controlling_coordinate, oldpos) local build_return = targetdef.execute_build(location.pos, clicker, layout.inventories, layout.protected, layout.nodes_dug, controlling_coordinate, oldpos)
if build_return == false then if build_return == false then
-- This happens if there's insufficient inventory, but we should have confirmed there was sufficient inventory during test phase. -- This happens if there's insufficient inventory, but we should have confirmed there was sufficient inventory during test phase.
-- So this should never happen. However, "should never happens" happen sometimes. So -- So this should never happen. However, "should never happens" happen sometimes. So
@ -299,7 +300,7 @@ digtron.execute_dig_cycle = function(pos, clicker)
-- finally, dig out any nodes remaining to be dug. Some of these will have had their flag revoked because -- finally, dig out any nodes remaining to be dug. Some of these will have had their flag revoked because
-- a builder put something there or because they're another digtron node. -- a builder put something there or because they're another digtron node.
local node_to_dig, whether_to_dig = nodes_dug:pop() local node_to_dig, whether_to_dig = layout.nodes_dug:pop()
while node_to_dig ~= nil do while node_to_dig ~= nil do
if whether_to_dig == true then if whether_to_dig == true then
minetest.log("action", string.format("%s uses Digtron to dig %s at (%d, %d, %d)", clicker:get_player_name(), minetest.get_node(node_to_dig).name, node_to_dig.x, node_to_dig.y, node_to_dig.z)) minetest.log("action", string.format("%s uses Digtron to dig %s at (%d, %d, %d)", clicker:get_player_name(), minetest.get_node(node_to_dig).name, node_to_dig.x, node_to_dig.y, node_to_dig.z))
@ -308,7 +309,7 @@ digtron.execute_dig_cycle = function(pos, clicker)
-- all of the digtron's nodes wind up in nodes_dug, so this is an ideal place to stick -- all of the digtron's nodes wind up in nodes_dug, so this is an ideal place to stick
-- a check to make sand fall after the digtron has passed. -- a check to make sand fall after the digtron has passed.
minetest.check_for_falling({x=node_to_dig.x, y=node_to_dig.y+1, z=node_to_dig.z}) minetest.check_for_falling({x=node_to_dig.x, y=node_to_dig.y+1, z=node_to_dig.z})
node_to_dig, whether_to_dig = nodes_dug:pop() node_to_dig, whether_to_dig = layout.nodes_dug:pop()
end end
return pos, status_text, 0 return pos, status_text, 0
end end
@ -317,7 +318,7 @@ end
-- Simplified version of the above method that only moves, and doesn't execute diggers or builders. -- Simplified version of the above method that only moves, and doesn't execute diggers or builders.
digtron.execute_move_cycle = function(pos, clicker) digtron.execute_move_cycle = function(pos, clicker)
local meta = minetest.get_meta(pos) local meta = minetest.get_meta(pos)
local layout = digtron.get_all_digtron_neighbours(pos, clicker) local layout = DigtronLayout.create(pos, clicker)
local status_text = "" local status_text = ""
local status_text, return_code = neighbour_test(layout, status_text) local status_text, return_code = neighbour_test(layout, status_text)
@ -328,17 +329,12 @@ digtron.execute_move_cycle = function(pos, clicker)
local facing = minetest.get_node(pos).param2 local facing = minetest.get_node(pos).param2
local controlling_coordinate = digtron.get_controlling_coordinate(pos, facing) local controlling_coordinate = digtron.get_controlling_coordinate(pos, facing)
local nodes_dug = Pointset.create() -- empty set, we're not digging anything -- if the player is standing within the array or next to it, move him too.
local move_player = move_player_test(layout, clicker)
-- test if any digtrons are obstructed by non-digtron nodes that haven't been marked -- test if any digtrons are obstructed by non-digtron nodes
-- as having been dug. layout:move_layout_image(facing, clicker:get_player_name())
local can_move = true local can_move = layout:can_write_layout_image(clicker)
for _, location in pairs(layout.all) do
local newpos = digtron.find_new_pos(location, facing)
if not digtron.can_move_to(newpos, layout.protected, nodes_dug) then
can_move = false
end
end
if not can_move then if not can_move then
-- mark this node as waiting, will clear this flag in digtron.cycle_time seconds -- mark this node as waiting, will clear this flag in digtron.cycle_time seconds
@ -351,16 +347,11 @@ digtron.execute_move_cycle = function(pos, clicker)
minetest.sound_play("truck", {gain=1.0, pos=pos}) minetest.sound_play("truck", {gain=1.0, pos=pos})
-- if the player is standing within the array or next to it, move him too.
local move_player = move_player_test(layout, clicker)
--move the array --move the array
digtron.move_digtron(facing, layout.all, layout.extents, nodes_dug) layout:write_layout_image()
local oldpos = {x=pos.x, y=pos.y, z=pos.z}
pos = digtron.find_new_pos(pos, facing) pos = digtron.find_new_pos(pos, facing)
if move_player then if move_player then
clicker:moveto(digtron.find_new_pos(clicker:getpos(), facing), true) clicker:moveto(digtron.find_new_pos(clicker:getpos(), facing), true)
end end
return pos, "", 0 return pos, "", 0
end end

@ -1,98 +0,0 @@
digtron.move_node = function(pos, newpos, player_name)
-- Moves nodes, preserving digtron metadata and inventory
local node = minetest.get_node(pos)
local node_def = minetest.registered_nodes[node.name]
local oldnode = minetest.get_node(newpos)
minetest.log("action", string.format("%s moves %s from (%d, %d, %d) to (%d, %d, %d), displacing %s", player_name, node.name, pos.x, pos.y, pos.z, newpos.x, newpos.y, newpos.z, oldnode.name))
minetest.add_node(newpos, { name=node.name, param1=node.param1, param2=node.param2 })
-- copy the metadata
local oldmeta_table = minetest.get_meta(pos):to_table()
local meta = minetest.get_meta(newpos)
meta:from_table(oldmeta_table)
meta:set_string("waiting", nil) -- If a controller moves another controller that's in the waiting state, clear the waiting state otherwise it might get stuck like that (we've moved it away from the target of the pending 'clear the waiting state' delegate call). That means you can run a digtron as fast as you want by rapidly clicking between two different controllers, but shhh - don't tell the player that.
-- Move the little floaty entity inside the builders
if minetest.get_item_group(node.name, "digtron") == 4 then
digtron.update_builder_item(newpos)
end
if node_def.after_place_node then
node_def.after_place_node(newpos)
end
-- remove node from old position
minetest.remove_node(pos)
if node_def.after_dig_node then
node_def.after_dig_node(pos)
end
end
digtron.move_digtron = function(facing, digtrons, extents, nodes_dug, player_name)
-- move everything. Note! order is important or they'll step on each other, that's why this has complicated loops and filtering.
-- Nodes are moved in a "caterpillar" pattern - front plane first, then next plane back, then next plane back, etc.
-- positions in the digtron list will be updated when this method executes. Note that the inventories list shares
-- references to the node position tables in the digtron list, so it will reflect the updates too.
local dir = digtron.facedir_to_dir_map[facing]
local increment
local filter
local index
local target
if dir == 1 then -- z+
filter = "z"
increment = -1
index = extents.max_z
target = extents.min_z
extents.max_z = extents.max_z + 1
extents.min_z = extents.min_z + 1
elseif dir == 2 then -- x+
filter = "x"
increment = -1
index = extents.max_x
target = extents.min_x
extents.max_x = extents.max_x + 1
extents.min_x = extents.min_x + 1
elseif dir == 3 then -- z-
filter = "z"
increment = 1
index = extents.min_z
target = extents.max_z
extents.max_z = extents.max_z - 1
extents.min_z = extents.min_z - 1
elseif dir == 4 then -- x-
filter = "x"
increment = 1
index = extents.min_x
target = extents.max_x
extents.max_x = extents.max_x - 1
extents.min_x = extents.min_x - 1
elseif dir == 5 then -- y-
filter = "y"
increment = 1
index = extents.min_y
target = extents.max_y
extents.max_y = extents.max_y - 1
extents.min_y = extents.min_y - 1
elseif dir == 6 then -- y+
filter = "y"
increment = -1
index = extents.max_y
target = extents.min_y
extents.max_y = extents.max_y + 1
extents.min_y = extents.min_y + 1
end
while index ~= target + increment do
for k, location in pairs(digtrons) do
if location[filter] == index then
local newpos = digtron.find_new_pos(location, facing)
digtron.move_node(location, newpos, player_name)
--By updating the digtron position table in-place we also update all the special node tables as well
digtrons[k].x= newpos.x
digtrons[k].y= newpos.y
digtrons[k].z= newpos.z
nodes_dug:set(newpos.x, newpos.y, newpos.z, false) -- we've moved a digtron node into this space, mark it so that we don't dig it.
end
end
index = index + increment
end
end