mirror of
https://github.com/minetest-mods/digtron.git
synced 2025-01-03 17:37:28 +01:00
removing the old get_all_digtron_neighbours
This is basically working, but still needs revisions to take advantage of the new information being stored in the image data. It should be possible to do all the temporary inventory work directly on the image file so that no put-back-in-inventory steps will be needed any more. Much nicer.
This commit is contained in:
FaceDeer
parent
38e1cbc41e
commit
eaae4276fc
8
util.lua
8
util.lua
@ -103,7 +103,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
|
||||
local itemstack = ItemStack(itemname)
|
||||
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)
|
||||
if itemstack:is_empty() then
|
||||
return nil
|
||||
@ -131,10 +131,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
|
||||
local itemstack = ItemStack(itemname)
|
||||
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)
|
||||
if not output:is_empty() then
|
||||
return location
|
||||
return location.pos
|
||||
end
|
||||
end
|
||||
return nil
|
||||
@ -162,7 +162,7 @@ digtron.burn = function(fuelstore_positions, target, test)
|
||||
if current_burned > target then
|
||||
break
|
||||
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")
|
||||
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
|
||||
|
||||
@ -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 status_text = string.format("Heat remaining in controller furnace: %d", fuel_burning)
|
||||
|
||||
local layout = digtron.get_all_digtron_neighbours(pos, clicker)
|
||||
local layout = digtron.get_layout_image(pos, clicker)
|
||||
|
||||
local status_text, return_code = neighbour_test(layout, status_text)
|
||||
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 digging_fuel_cost = 0
|
||||
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.
|
||||
-- If we dug them now, sand would fall and some digtron nodes would die.
|
||||
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]
|
||||
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
|
||||
for _, itemname in pairs(dropped) do
|
||||
table.insert(items_dropped, itemname)
|
||||
end
|
||||
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
|
||||
digging_fuel_cost = digging_fuel_cost + fuel_cost
|
||||
@ -137,8 +136,8 @@ digtron.execute_dig_cycle = function(pos, clicker)
|
||||
-- as having been dug.
|
||||
local can_move = true
|
||||
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
|
||||
local newpos = digtron.find_new_pos(location.pos, facing)
|
||||
if not digtron.can_move_to(newpos, layout.protected, layout.nodes_dug) then
|
||||
can_move = false
|
||||
end
|
||||
end
|
||||
@ -165,11 +164,11 @@ digtron.execute_dig_cycle = function(pos, clicker)
|
||||
local test_fuel_items = {}
|
||||
local test_build_fuel_cost = 0
|
||||
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 test_location = digtron.find_new_pos(location, facing)
|
||||
local test_location = digtron.find_new_pos(location.pos, facing)
|
||||
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
|
||||
can_build = false
|
||||
break
|
||||
@ -233,32 +232,35 @@ digtron.execute_dig_cycle = function(pos, clicker)
|
||||
-- damage the weak flesh
|
||||
if digtron.diggers_damage_creatures then
|
||||
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]
|
||||
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
|
||||
|
||||
--move the array
|
||||
digtron.move_digtron(facing, layout.all, layout.extents, nodes_dug, clicker:get_player_name())
|
||||
digtron.move_layout_image(layout, facing, clicker:get_player_name())
|
||||
digtron.write_layout_image(layout)
|
||||
local oldpos = {x=pos.x, y=pos.y, z=pos.z}
|
||||
pos = digtron.find_new_pos(pos, facing)
|
||||
meta = minetest.get_meta(pos)
|
||||
if move_player then
|
||||
local player_pos = clicker:getpos()
|
||||
clicker:moveto(digtron.find_new_pos(player_pos, facing), true)
|
||||
end
|
||||
|
||||
|
||||
local building_fuel_cost = 0
|
||||
local strange_failure = false
|
||||
-- execute_build on all digtron components that have one
|
||||
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]
|
||||
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.
|
||||
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
|
||||
-- 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
|
||||
@ -299,7 +301,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
|
||||
-- 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
|
||||
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))
|
||||
@ -308,7 +310,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
|
||||
-- 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})
|
||||
node_to_dig, whether_to_dig = nodes_dug:pop()
|
||||
node_to_dig, whether_to_dig = layout.nodes_dug:pop()
|
||||
end
|
||||
return pos, status_text, 0
|
||||
end
|
||||
@ -317,7 +319,7 @@ end
|
||||
-- Simplified version of the above method that only moves, and doesn't execute diggers or builders.
|
||||
digtron.execute_move_cycle = function(pos, clicker)
|
||||
local meta = minetest.get_meta(pos)
|
||||
local layout = digtron.get_all_digtron_neighbours(pos, clicker)
|
||||
local layout = digtron.get_layout_image(pos, clicker)
|
||||
|
||||
local status_text = ""
|
||||
local status_text, return_code = neighbour_test(layout, status_text)
|
||||
@ -327,18 +329,13 @@ digtron.execute_move_cycle = function(pos, clicker)
|
||||
|
||||
local facing = minetest.get_node(pos).param2
|
||||
local controlling_coordinate = digtron.get_controlling_coordinate(pos, facing)
|
||||
|
||||
local nodes_dug = Pointset.create() -- empty set, we're not digging anything
|
||||
|
||||
-- test if any digtrons are obstructed by non-digtron nodes that haven't been marked
|
||||
-- as having been dug.
|
||||
local can_move = true
|
||||
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 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
|
||||
digtron.move_layout_image(layout, facing, clicker:get_player_name())
|
||||
local can_move = digtron.can_write_layout_image(layout, clicker)
|
||||
|
||||
if not can_move then
|
||||
-- mark this node as waiting, will clear this flag in digtron.cycle_time seconds
|
||||
@ -350,15 +347,12 @@ digtron.execute_move_cycle = function(pos, clicker)
|
||||
end
|
||||
|
||||
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
|
||||
digtron.move_digtron(facing, layout.all, layout.extents, nodes_dug)
|
||||
local oldpos = {x=pos.x, y=pos.y, z=pos.z}
|
||||
digtron.write_layout_image(layout)
|
||||
pos = digtron.find_new_pos(pos, facing)
|
||||
if move_player then
|
||||
local player_pos = clicker:getpos()
|
||||
clicker:moveto(digtron.find_new_pos(player_pos, facing), true)
|
||||
end
|
||||
|
||||
|
||||
217
util_layout.lua
217
util_layout.lua
@ -1,118 +1,3 @@
|
||||
digtron.get_all_digtron_neighbours = function(pos, player)
|
||||
-- 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)
|
||||
|
||||
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
|
||||
layout.traction = 0
|
||||
layout.all = {}
|
||||
layout.inventories = {}
|
||||
layout.fuelstores = {}
|
||||
layout.diggers = {}
|
||||
layout.builders = {}
|
||||
layout.extents = {}
|
||||
layout.water_touching = false
|
||||
layout.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.
|
||||
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
|
||||
|
||||
table.insert(layout.all, layout.controller)
|
||||
layout.extents.max_x = pos.x
|
||||
layout.extents.min_x = pos.x
|
||||
layout.extents.max_y = pos.y
|
||||
layout.extents.min_y = pos.y
|
||||
layout.extents.max_z = pos.z
|
||||
layout.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
|
||||
layout.protected:set(pos.x, pos.y, pos.z, 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.
|
||||
layout.all = 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
|
||||
|
||||
if minetest.get_item_group(node.name, "water") ~= 0 then
|
||||
layout.water_touching = true
|
||||
elseif minetest.get_item_group(node.name, "lava") ~= 0 then
|
||||
layout.lava_touching = true
|
||||
if digtron.lava_impassible == true then
|
||||
layout.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
|
||||
table.insert(layout.all, testpos)
|
||||
|
||||
-- update extents
|
||||
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
|
||||
if group_number == 2 then
|
||||
table.insert(layout.inventories, testpos)
|
||||
elseif group_number == 3 then
|
||||
table.insert(layout.diggers, testpos)
|
||||
elseif group_number == 4 then
|
||||
table.insert(layout.builders, testpos)
|
||||
elseif group_number == 5 then
|
||||
table.insert(layout.fuelstores, testpos)
|
||||
elseif group_number == 6 then
|
||||
table.insert(layout.inventories, testpos)
|
||||
table.insert(layout.fuelstores, testpos)
|
||||
end
|
||||
|
||||
--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.
|
||||
layout.traction = layout.traction + 1
|
||||
end
|
||||
|
||||
testpos, _ = to_test:pop()
|
||||
end
|
||||
|
||||
return layout
|
||||
end
|
||||
|
||||
-- Rotation magic
|
||||
--------------------------------------------------------------------------------------------------------
|
||||
|
||||
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
|
||||
@ -216,6 +101,7 @@ local rotate_node_image = function(node_image, origin, axis, direction, old_pos_
|
||||
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)
|
||||
digtron.rotate_layout_image = function(layout_image, facedir)
|
||||
-- To convert this into the direction the "top" of the axel node is pointing in:
|
||||
-- 0, 1, 2, 3 == (0,1,0)
|
||||
@ -234,8 +120,6 @@ digtron.rotate_layout_image = function(layout_image, facedir)
|
||||
{axis="y", dir=1},
|
||||
}
|
||||
local params = top[math.floor(facedir/4)]
|
||||
|
||||
layout_image.old_pos_pointset = Pointset:create()
|
||||
|
||||
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)
|
||||
@ -243,6 +127,51 @@ digtron.rotate_layout_image = function(layout_image, facedir)
|
||||
return layout_image
|
||||
end
|
||||
|
||||
digtron.move_layout_image = function(layout_image, facing, player_name)
|
||||
local extents = layout_image.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(layout_image.all) do
|
||||
layout_image.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
|
||||
layout_image.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
|
||||
|
||||
digtron.can_write_layout_image = function(layout_image, player)
|
||||
for k, node_image in pairs(layout_image.all) do
|
||||
if not layout_image.old_pos_pointset:get(node_image.pos.x, node_image.pos.y, node_image.pos.z)
|
||||
@ -279,17 +208,28 @@ digtron.write_layout_image = function(layout_image)
|
||||
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.
|
||||
-- Similar to get_layout, but far more comprehensive. This produces a data structure that will allow the digtron to be rotated and then recreated in its entirety.
|
||||
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.traction = 0
|
||||
image.all = {}
|
||||
image.inventories = {}
|
||||
image.fuelstores = {}
|
||||
image.diggers = {}
|
||||
image.builders = {}
|
||||
image.extents = {}
|
||||
image.water_touching = false
|
||||
image.lava_touching = false
|
||||
image.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.
|
||||
image.old_pos_pointset = Pointset.create() -- For tracking original location of nodes if we do transformations on the Digtron
|
||||
image.nodes_dug = Pointset.create() -- For tracking adjacent nodes that will have been dug by digger heads in future
|
||||
image.contains_protected_node = false -- used to indicate if at least one node in this digtron array is protected from the player.
|
||||
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
|
||||
|
||||
table.insert(image.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.
|
||||
|
||||
image.extents.max_x = pos.x
|
||||
image.extents.min_x = pos.x
|
||||
@ -311,6 +251,7 @@ digtron.get_layout_image = function(pos, player)
|
||||
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.protected:set(pos.x, pos.y, pos.z, true)
|
||||
image.contains_protected_node = true
|
||||
end
|
||||
|
||||
@ -326,11 +267,36 @@ digtron.get_layout_image = function(pos, player)
|
||||
return nil
|
||||
end
|
||||
|
||||
if minetest.get_item_group(node.name, "water") ~= 0 then
|
||||
image.water_touching = true
|
||||
elseif minetest.get_item_group(node.name, "lava") ~= 0 then
|
||||
image.lava_touching = true
|
||||
if digtron.lava_impassible == true then
|
||||
image.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
|
||||
table.insert(image.all, get_node_image(testpos, node))
|
||||
local node_image = get_node_image(testpos, node)
|
||||
|
||||
table.insert(image.all, node_image)
|
||||
|
||||
-- add a reference to this node's position to special node lists
|
||||
if group_number == 2 then
|
||||
table.insert(image.inventories, node_image)
|
||||
elseif group_number == 3 then
|
||||
table.insert(image.diggers, node_image)
|
||||
elseif group_number == 4 then
|
||||
table.insert(image.builders, node_image)
|
||||
elseif group_number == 5 then
|
||||
table.insert(image.fuelstores, node_image)
|
||||
elseif group_number == 6 then
|
||||
table.insert(image.inventories, node_image)
|
||||
table.insert(image.fuelstores, node_image)
|
||||
end
|
||||
|
||||
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
|
||||
@ -350,6 +316,9 @@ digtron.get_layout_image = function(pos, player)
|
||||
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.
|
||||
image.traction = image.traction + 1
|
||||
end
|
||||
|
||||
testpos, _ = to_test:pop()
|
||||
|
||||
Loading…
Reference in New Issue
Block a user