1349 lines
30 KiB
Lua
1349 lines
30 KiB
Lua
local utils = ...
|
|
local S = utils.S
|
|
|
|
|
|
|
|
if utils.digilines_supported or utils.mesecon_supported then
|
|
|
|
|
|
|
|
local piston_interval = 0.2
|
|
|
|
|
|
|
|
local function direction_vector (node)
|
|
local axis = math.floor (node.param2 / 4)
|
|
local rotate = node.param2 % 4
|
|
local vec = { x = 0, y = 0, z = 0 }
|
|
|
|
if rotate == 0 then
|
|
vec = { x = 0, y = 0, z = -1 }
|
|
elseif rotate == 1 then
|
|
vec = { x = -1, y = 0, z = 0 }
|
|
elseif rotate == 2 then
|
|
vec = { x = 0, y = 0, z = 1 }
|
|
elseif rotate == 3 then
|
|
vec = { x = 1, y = 0, z = 0 }
|
|
end
|
|
|
|
if axis == 1 then
|
|
vec = vector.rotate (vec, { x = math.pi / -2, y = 0, z = 0 })
|
|
elseif axis == 2 then
|
|
vec = vector.rotate (vec, { x = math.pi / 2, y = 0, z = 0 })
|
|
elseif axis == 3 then
|
|
vec = vector.rotate (vec, { x = 0, y = 0, z = math.pi / 2 })
|
|
elseif axis == 4 then
|
|
vec = vector.rotate (vec, { x = 0, y = 0, z = math.pi / -2 })
|
|
elseif axis == 5 then
|
|
vec = vector.rotate (vec, { x = math.pi, y = 0, z = 0 })
|
|
end
|
|
|
|
return vec
|
|
end
|
|
|
|
|
|
|
|
local function push_entities (pos, movedir, entity_list, upper_limit)
|
|
local objects = minetest.get_objects_inside_radius (pos, 1.5)
|
|
|
|
for _, obj in ipairs (objects) do
|
|
if obj.get_pos and obj.move_to then
|
|
local opos = obj:get_pos ()
|
|
|
|
if opos.x > (pos.x - 0.5) and opos.x < (pos.x + 0.5) and
|
|
opos.z > (pos.z - 0.5) and opos.z < (pos.z + 0.5) and
|
|
opos.y >= (pos.y - 0.5) and opos.y < (pos.y + upper_limit) then
|
|
|
|
local newpos = vector.add (opos, movedir)
|
|
local node = utils.get_far_node (vector.round (newpos))
|
|
local def = (node and utils.find_item_def (node.name)) or nil
|
|
|
|
if (node.name == "air") or (def and not def.walkable) then
|
|
|
|
entity_list[#entity_list + 1] =
|
|
{
|
|
obj = obj,
|
|
pos = newpos
|
|
}
|
|
|
|
obj:move_to (newpos)
|
|
else
|
|
entity_list[#entity_list + 1] =
|
|
{
|
|
obj = obj,
|
|
pos = opos
|
|
}
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
|
|
|
|
local function update_player_position (player_list)
|
|
for _, entry in ipairs (player_list) do
|
|
local player = minetest.get_player_by_name (entry.name)
|
|
|
|
if player then
|
|
local pos = player:get_pos ()
|
|
|
|
if pos.y < entry.pos.y then
|
|
pos.y = entry.pos.y
|
|
player:set_pos (pos)
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
|
|
|
|
local function queue_player_update (entity_list, movedir)
|
|
local players = { }
|
|
|
|
for _, entry in ipairs (entity_list) do
|
|
if entry.obj and entry.obj:is_player () then
|
|
players[#players + 1] =
|
|
{
|
|
pos = entry.pos,
|
|
name = entry.obj:get_player_name ()
|
|
}
|
|
end
|
|
end
|
|
|
|
if #players > 0 then
|
|
minetest.after(0.1, update_player_position, players)
|
|
end
|
|
end
|
|
|
|
|
|
|
|
local rules_alldirs =
|
|
{
|
|
{x = 1, y = 0, z = 0},
|
|
{x = -1, y = 0, z = 0},
|
|
{x = 0, y = 1, z = 0},
|
|
{x = 0, y = -1, z = 0},
|
|
{x = 0, y = 0, z = 1},
|
|
{x = 0, y = 0, z = -1},
|
|
}
|
|
|
|
|
|
|
|
local function add_pos_to_list (pos, dir, movedir, node_list, check_list)
|
|
local hash = minetest.hash_node_position (pos)
|
|
|
|
if not check_list[hash] then
|
|
if minetest.is_protected (pos, "") then
|
|
return 0
|
|
end
|
|
|
|
local node = utils.get_far_node (pos)
|
|
|
|
if not node then
|
|
return 0
|
|
end
|
|
|
|
local def = utils.find_item_def (node.name)
|
|
|
|
if node.name == "air" or (def and def.buildable_to) then
|
|
return 1
|
|
end
|
|
|
|
local meta = minetest.get_meta (pos)
|
|
local timer = minetest.get_node_timer (pos)
|
|
|
|
check_list[hash] = true
|
|
|
|
node_list[#node_list + 1] =
|
|
{
|
|
node = node,
|
|
def = def,
|
|
pos = vector.new (pos),
|
|
newpos = vector.add (pos, movedir),
|
|
meta = (meta and meta:to_table ()) or { },
|
|
node_timer =
|
|
{
|
|
(timer and timer:get_timeout ()) or 0,
|
|
(timer and timer:get_elapsed ()) or 0
|
|
}
|
|
}
|
|
|
|
if def.mvps_sticky then
|
|
local sides = def.mvps_sticky (pos, node)
|
|
|
|
for _, r in ipairs (sides) do
|
|
if add_pos_to_list (r, dir, movedir, node_list, check_list) == 0 then
|
|
return 0
|
|
end
|
|
end
|
|
end
|
|
|
|
-- If adjacent node is sticky block and connects add that
|
|
-- position to the connected table
|
|
for _, r in ipairs (rules_alldirs) do
|
|
local apos = vector.add (pos, r)
|
|
local anode = utils.get_far_node (apos)
|
|
local adef = (anode and minetest.registered_nodes[anode.name]) or nil
|
|
|
|
if adef and adef.mvps_sticky then
|
|
local sides = adef.mvps_sticky (apos, anode)
|
|
|
|
-- connects to this position?
|
|
for _, link in ipairs (sides) do
|
|
if vector.equals (link, pos) then
|
|
if add_pos_to_list (apos, dir, movedir, node_list, check_list) == 0 then
|
|
return 0
|
|
end
|
|
|
|
break
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
return 2
|
|
end
|
|
|
|
|
|
|
|
local function node_list_last_pos (pos, node_list, length)
|
|
local movedir = node_list.movedir
|
|
local base_pos = node_list.base_pos
|
|
|
|
if movedir then
|
|
if movedir.x ~= 0 then
|
|
return vector.new ({
|
|
x = base_pos.x + (movedir.x * length),
|
|
y = pos.y,
|
|
z = pos.z
|
|
})
|
|
elseif movedir.z ~= 0 then
|
|
return vector.new ({
|
|
x = pos.x,
|
|
y = pos.y,
|
|
z = base_pos.z + (movedir.z * length)
|
|
})
|
|
elseif movedir.y ~= 0 then
|
|
return vector.new ({
|
|
x = pos.x,
|
|
y = base_pos.y + (movedir.y * length),
|
|
z = pos.z
|
|
})
|
|
end
|
|
end
|
|
|
|
return pos
|
|
end
|
|
|
|
|
|
|
|
local function get_node_list (pos, extent, length, maxnodes, pushing, node_list, check_list)
|
|
local node = utils.get_far_node (pos)
|
|
node_list = node_list or { }
|
|
check_list = check_list or { }
|
|
|
|
if node then
|
|
local dir = vector.round (direction_vector (node))
|
|
local movedir = vector.round ((pushing and dir) or vector.multiply (dir, -1))
|
|
|
|
node_list.dir = dir
|
|
node_list.movedir = movedir
|
|
node_list.base_pos = vector.add (pos, vector.multiply (dir, extent))
|
|
node_list.length = length
|
|
node_list.maxnodes = maxnodes
|
|
|
|
check_list[minetest.hash_node_position (vector.add (pos, vector.multiply (dir, extent - 1)))] = true
|
|
|
|
for i = 0, length - 1, 1 do
|
|
local tpos = vector.add (pos, vector.multiply (dir, extent + i))
|
|
|
|
local result = add_pos_to_list (tpos, dir, movedir, node_list, check_list)
|
|
|
|
if result == 0 then
|
|
return false
|
|
elseif result == 1 then
|
|
break
|
|
end
|
|
end
|
|
|
|
-- get any ahead of stickyblocks to limit
|
|
local copy_list = table.copy (node_list)
|
|
|
|
for _, n in ipairs (copy_list) do
|
|
local hash = minetest.hash_node_position (n.newpos)
|
|
|
|
if not check_list[hash] then
|
|
local last_pos = node_list_last_pos (n.newpos, node_list, length)
|
|
local this_pos = vector.new (n.newpos)
|
|
local count = 0
|
|
|
|
while not vector.equals (this_pos, last_pos) and count < length do
|
|
local result = add_pos_to_list (this_pos, dir, movedir, node_list, check_list)
|
|
|
|
if result == 0 then
|
|
return false
|
|
elseif result == 1 then
|
|
break
|
|
end
|
|
|
|
count = count + 1
|
|
this_pos = vector.add (this_pos, movedir)
|
|
end
|
|
end
|
|
end
|
|
|
|
return true
|
|
end
|
|
|
|
return false
|
|
end
|
|
|
|
|
|
|
|
local function can_node_list_move (node_list, check_list)
|
|
local movedir = node_list.movedir
|
|
local radius = math.floor (node_list.maxnodes / 2)
|
|
local base_pos = node_list.base_pos
|
|
|
|
if movedir then
|
|
for _, n in ipairs (node_list) do
|
|
-- check connected stickyblocks don't extend too far laterally
|
|
if movedir.x ~= 0 then
|
|
if math.abs (n.pos.y - base_pos.y) > radius or
|
|
math.abs (n.pos.z - base_pos.z) > radius then
|
|
return false
|
|
end
|
|
elseif movedir.z ~= 0 then
|
|
if math.abs (n.pos.y - base_pos.y) > radius or
|
|
math.abs (n.pos.x - base_pos.x) > radius then
|
|
return false
|
|
end
|
|
elseif movedir.y ~= 0 then
|
|
if math.abs (n.pos.x - base_pos.x) > radius or
|
|
math.abs (n.pos.z - base_pos.z) > radius then
|
|
return false
|
|
end
|
|
end
|
|
|
|
-- check moving to is clear
|
|
if not check_list[minetest.hash_node_position (n.newpos)] then
|
|
local node = utils.get_far_node (n.newpos)
|
|
local def = (node and utils.find_item_def (node.name)) or nil
|
|
|
|
if node.name ~= "air" and def and not def.buildable_to then
|
|
return false
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
return true
|
|
end
|
|
|
|
|
|
|
|
local function sort_node_list (node_list)
|
|
local movedir = node_list.movedir
|
|
|
|
if movedir then
|
|
if movedir.x > 0 then
|
|
table.sort (node_list , function (n1, n2)
|
|
return n1.pos.x > n2.pos.x
|
|
end)
|
|
elseif movedir.x < 0 then
|
|
table.sort (node_list , function (n1, n2)
|
|
return n1.pos.x < n2.pos.x
|
|
end)
|
|
elseif movedir.z > 0 then
|
|
table.sort (node_list , function (n1, n2)
|
|
return n1.pos.z > n2.pos.z
|
|
end)
|
|
elseif movedir.z < 0 then
|
|
table.sort (node_list , function (n1, n2)
|
|
return n1.pos.z < n2.pos.z
|
|
end)
|
|
elseif movedir.y > 0 then
|
|
table.sort (node_list , function (n1, n2)
|
|
return n1.pos.y > n2.pos.y
|
|
end)
|
|
elseif movedir.y < 0 then
|
|
table.sort (node_list , function (n1, n2)
|
|
return n1.pos.y < n2.pos.y
|
|
end)
|
|
end
|
|
end
|
|
end
|
|
|
|
|
|
|
|
local on_mvps_move = function (node_list)
|
|
end
|
|
|
|
|
|
|
|
local is_mvps_stopper = function (node, movedir, node_list, id)
|
|
return false
|
|
end
|
|
|
|
|
|
|
|
local update_mesecons_connections_removed = function (node_list)
|
|
end
|
|
|
|
|
|
|
|
local update_mesecons_connections_added = function (node_list)
|
|
end
|
|
|
|
|
|
if utils.mesecon_supported then
|
|
if mesecon.on_mvps_move then
|
|
on_mvps_move = function (node_list)
|
|
for _, callback in ipairs (mesecon.on_mvps_move) do
|
|
callback (node_list)
|
|
end
|
|
end
|
|
end
|
|
|
|
if mesecon.is_mvps_stopper then
|
|
is_mvps_stopper = function (node, movedir, node_list, id)
|
|
return mesecon.is_mvps_stopper (node, movedir, node_list, id)
|
|
end
|
|
end
|
|
|
|
if mesecon.on_dignode then
|
|
update_mesecons_connections_removed = function (node_list)
|
|
for _, node in ipairs (node_list) do
|
|
mesecon.on_dignode (node.oldpos, node.node)
|
|
end
|
|
end
|
|
end
|
|
|
|
if mesecon.on_placenode then
|
|
update_mesecons_connections_added = function (node_list)
|
|
for _, node in ipairs (node_list) do
|
|
mesecon.on_placenode (node.pos, utils.get_far_node (node.pos))
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
|
|
|
|
local function push_nodes (pos, extent)
|
|
local node_list = { }
|
|
local check_list = { }
|
|
local entity_list = { }
|
|
local maxnodes = utils.settings.max_piston_nodes
|
|
|
|
if not get_node_list (pos, extent, maxnodes, maxnodes, true, node_list, check_list) then
|
|
return false
|
|
end
|
|
|
|
if not can_node_list_move (node_list, check_list, maxnodes) then
|
|
return false
|
|
end
|
|
|
|
sort_node_list (node_list)
|
|
|
|
for id, node in ipairs (node_list) do
|
|
if is_mvps_stopper (node.node, node_list.movedir, node_list, id) then
|
|
return false
|
|
end
|
|
end
|
|
|
|
for _, node in ipairs (node_list) do
|
|
node.oldpos = vector.new (node.pos)
|
|
node.pos = vector.new (node.newpos)
|
|
node.newpos = nil
|
|
|
|
minetest.remove_node (node.oldpos)
|
|
end
|
|
|
|
update_mesecons_connections_removed (node_list)
|
|
|
|
-- push entities in front first
|
|
for _, node in ipairs (node_list) do
|
|
if not check_list[minetest.hash_node_position (node.pos)] then
|
|
push_entities (node.pos, node_list.movedir, entity_list, 0.5)
|
|
end
|
|
end
|
|
|
|
for _, node in ipairs (node_list) do
|
|
push_entities (node.oldpos, node_list.movedir, entity_list, 1.0)
|
|
|
|
minetest.set_node (node.pos, node.node)
|
|
|
|
if node.meta then
|
|
local meta = minetest.get_meta (node.pos)
|
|
|
|
if meta then
|
|
meta:from_table (node.meta)
|
|
end
|
|
end
|
|
|
|
if node.node_timer[1] > 0 then
|
|
local timer = minetest.get_node_timer (node.pos)
|
|
|
|
if timer then
|
|
timer:set (node.node_timer[1], node.node_timer[2])
|
|
end
|
|
end
|
|
end
|
|
|
|
-- push any entities in front of pusher
|
|
push_entities (node_list.base_pos, node_list.movedir, entity_list, 0.5)
|
|
|
|
on_mvps_move (node_list)
|
|
update_mesecons_connections_added (node_list)
|
|
|
|
if node_list.movedir.y >= 0 then
|
|
queue_player_update (entity_list, node_list.movedir)
|
|
end
|
|
|
|
return true
|
|
end
|
|
|
|
|
|
|
|
local function pull_node (pos, extent)
|
|
local node_list = { }
|
|
local check_list = { }
|
|
local entity_list = { }
|
|
local maxnodes = utils.settings.max_piston_nodes
|
|
|
|
if not get_node_list (pos, extent, 1, maxnodes, false, node_list, check_list) then
|
|
return false
|
|
end
|
|
|
|
if not can_node_list_move (node_list, check_list, maxnodes) then
|
|
return false
|
|
end
|
|
|
|
sort_node_list (node_list)
|
|
|
|
for id, node in ipairs (node_list) do
|
|
if is_mvps_stopper (node.node, node_list.movedir, node_list, id) then
|
|
return false
|
|
end
|
|
end
|
|
|
|
for _, node in ipairs (node_list) do
|
|
node.oldpos = vector.new (node.pos)
|
|
node.pos = vector.new (node.newpos)
|
|
node.newpos = nil
|
|
|
|
minetest.remove_node (node.oldpos)
|
|
end
|
|
|
|
update_mesecons_connections_removed (node_list)
|
|
|
|
-- push entities in front first
|
|
for _, node in ipairs (node_list) do
|
|
if not check_list[minetest.hash_node_position (node.pos)] then
|
|
push_entities (node.pos, node_list.movedir, entity_list, 0.5)
|
|
end
|
|
end
|
|
|
|
for _, node in ipairs (node_list) do
|
|
push_entities (node.oldpos, node_list.movedir, entity_list, 1.0)
|
|
|
|
minetest.set_node (node.pos, node.node)
|
|
|
|
if node.meta then
|
|
local meta = minetest.get_meta (node.pos)
|
|
|
|
if meta then
|
|
meta:from_table (node.meta)
|
|
end
|
|
end
|
|
|
|
if node.node_timer[1] > 0 then
|
|
local timer = minetest.get_node_timer (node.pos)
|
|
|
|
if timer then
|
|
timer:set (node.node_timer[1], node.node_timer[2])
|
|
end
|
|
end
|
|
end
|
|
|
|
on_mvps_move (node_list)
|
|
update_mesecons_connections_added (node_list)
|
|
|
|
if node_list.movedir.y >= 0 then
|
|
queue_player_update (entity_list, node_list.movedir)
|
|
end
|
|
|
|
return true
|
|
end
|
|
|
|
|
|
|
|
local function place_blank (pos, extent)
|
|
local node = utils.get_far_node (pos)
|
|
|
|
if node then
|
|
local vec = direction_vector (node)
|
|
local blank_pos = vector.add (pos, vector.multiply (vec, extent))
|
|
local blank_node = utils.get_far_node (blank_pos)
|
|
local blank_def = blank_node and utils.find_item_def (blank_node.name)
|
|
|
|
if blank_node and blank_node.name == "air" or
|
|
(blank_def and not blank_def.walkable) then
|
|
|
|
minetest.set_node (blank_pos,
|
|
{
|
|
name = "lwcomponents:piston_blank_"..tostring (extent),
|
|
param2 = node.param2
|
|
})
|
|
end
|
|
end
|
|
end
|
|
|
|
|
|
|
|
local function remove_blank (pos, extent)
|
|
local node = utils.get_far_node (pos)
|
|
|
|
if node then
|
|
local vec = direction_vector (node)
|
|
local blank_pos = vector.add (pos, vector.multiply (vec, extent))
|
|
local blank_node = utils.get_far_node (blank_pos)
|
|
|
|
if blank_node and
|
|
blank_node.name == "lwcomponents:piston_blank_"..tostring (extent) then
|
|
|
|
minetest.remove_node (blank_pos)
|
|
end
|
|
end
|
|
end
|
|
|
|
|
|
|
|
local function extend_piston (pos, extent)
|
|
local node = utils.get_far_node (pos)
|
|
local meta = minetest.get_meta (pos)
|
|
|
|
if node and meta then
|
|
extent = math.max (math.min (tonumber (extent or 2), meta:get_int ("max_extent")), 0)
|
|
|
|
if node.name == "lwcomponents:piston" then
|
|
if extent ~= 0 then
|
|
if push_nodes (pos, 1) then
|
|
node.name = "lwcomponents:piston_1"
|
|
minetest.swap_node (pos, node)
|
|
place_blank (pos, 1)
|
|
minetest.sound_play ("lwpiston_extend",
|
|
{
|
|
pos = pos,
|
|
max_hear_distance = 20,
|
|
gain = 0.3
|
|
},
|
|
true)
|
|
|
|
if extent == 2 then
|
|
meta:set_int ("extent", 2)
|
|
minetest.get_node_timer (pos):start (piston_interval)
|
|
|
|
return true
|
|
end
|
|
end
|
|
end
|
|
|
|
elseif node.name == "lwcomponents:piston_1" then
|
|
if extent == 0 then
|
|
remove_blank (pos, 1)
|
|
node.name = "lwcomponents:piston"
|
|
minetest.swap_node (pos, node)
|
|
minetest.sound_play ("lwpiston_retract",
|
|
{
|
|
pos = pos,
|
|
max_hear_distance = 20,
|
|
gain = 0.3
|
|
},
|
|
true)
|
|
|
|
elseif extent == 2 then
|
|
if push_nodes (pos, 2) then
|
|
node.name = "lwcomponents:piston_2"
|
|
minetest.swap_node (pos, node)
|
|
place_blank (pos, 2)
|
|
minetest.sound_play ("lwpiston_extend",
|
|
{
|
|
pos = pos,
|
|
max_hear_distance = 20,
|
|
gain = 0.3
|
|
},
|
|
true)
|
|
end
|
|
end
|
|
|
|
elseif node.name == "lwcomponents:piston_2" then
|
|
if extent ~= 2 then
|
|
remove_blank (pos, 2)
|
|
node.name = "lwcomponents:piston_1"
|
|
minetest.swap_node (pos, node)
|
|
minetest.sound_play ("lwpiston_retract",
|
|
{
|
|
pos = pos,
|
|
max_hear_distance = 20,
|
|
gain = 0.3
|
|
},
|
|
true)
|
|
|
|
if extent == 0 then
|
|
meta:set_int ("extent", 0)
|
|
minetest.get_node_timer (pos):start (piston_interval)
|
|
|
|
return true
|
|
end
|
|
end
|
|
|
|
elseif node.name == "lwcomponents:piston_sticky" then
|
|
if extent ~= 0 then
|
|
if push_nodes (pos, 1) then
|
|
node.name = "lwcomponents:piston_sticky_1"
|
|
minetest.swap_node (pos, node)
|
|
place_blank (pos, 1)
|
|
minetest.sound_play ("lwpiston_extend",
|
|
{
|
|
pos = pos,
|
|
max_hear_distance = 20,
|
|
gain = 0.3
|
|
},
|
|
true)
|
|
|
|
if extent == 2 then
|
|
meta:set_int ("extent", 2)
|
|
minetest.get_node_timer (pos):start (piston_interval)
|
|
|
|
return true
|
|
end
|
|
end
|
|
end
|
|
|
|
|
|
elseif node.name == "lwcomponents:piston_sticky_1" then
|
|
if extent == 0 then
|
|
remove_blank (pos, 1)
|
|
node.name = "lwcomponents:piston_sticky"
|
|
minetest.swap_node (pos, node)
|
|
pull_node (pos, 2)
|
|
minetest.sound_play ("lwpiston_retract",
|
|
{
|
|
pos = pos,
|
|
max_hear_distance = 20,
|
|
gain = 0.3
|
|
},
|
|
true)
|
|
|
|
elseif extent == 2 then
|
|
if push_nodes (pos, 2) then
|
|
node.name = "lwcomponents:piston_sticky_2"
|
|
minetest.swap_node (pos, node)
|
|
place_blank (pos, 2)
|
|
minetest.sound_play ("lwpiston_extend",
|
|
{
|
|
pos = pos,
|
|
max_hear_distance = 20,
|
|
gain = 0.3
|
|
},
|
|
true)
|
|
end
|
|
end
|
|
|
|
elseif node.name == "lwcomponents:piston_sticky_2" then
|
|
if extent ~= 2 then
|
|
remove_blank (pos, 2)
|
|
node.name = "lwcomponents:piston_sticky_1"
|
|
minetest.swap_node (pos, node)
|
|
pull_node (pos, 3)
|
|
minetest.sound_play ("lwpiston_retract",
|
|
{
|
|
pos = pos,
|
|
max_hear_distance = 20,
|
|
gain = 0.3
|
|
},
|
|
true)
|
|
|
|
if extent == 0 then
|
|
meta:set_int ("extent", 0)
|
|
minetest.get_node_timer (pos):start (piston_interval)
|
|
|
|
return true
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
return false
|
|
end
|
|
|
|
|
|
|
|
local function on_destruct_1 (pos)
|
|
remove_blank (pos, 1)
|
|
end
|
|
|
|
|
|
|
|
local function on_destruct_2 (pos)
|
|
remove_blank (pos, 2)
|
|
remove_blank (pos, 1)
|
|
end
|
|
|
|
|
|
|
|
local function on_place (itemstack, placer, pointed_thing)
|
|
local param2 = 0
|
|
|
|
if placer and placer:is_player () then
|
|
param2 = minetest.dir_to_facedir (placer:get_look_dir (), true)
|
|
elseif pointed_thing and pointed_thing.type == "node" then
|
|
param2 = minetest.dir_to_facedir (vector.subtract (pointed_thing.under, pointed_thing.above), true)
|
|
end
|
|
|
|
return minetest.item_place (itemstack, placer, pointed_thing, param2)
|
|
end
|
|
|
|
|
|
|
|
|
|
local function after_place_node (pos, placer, itemstack, pointed_thing)
|
|
local meta = minetest.get_meta (pos)
|
|
local spec =
|
|
"size[7,3.3]"..
|
|
"field[1,1;4,2;channel;Channel;${channel}]"..
|
|
"button_exit[4.6,1.15;1.5,1;submit;Set]"..
|
|
"checkbox[1,2;single;Single move;false]"
|
|
|
|
meta:set_string ("formspec", spec)
|
|
meta:set_int ("max_extent", 2)
|
|
|
|
-- If return true no item is taken from itemstack
|
|
return false
|
|
end
|
|
|
|
|
|
|
|
local function on_receive_fields (pos, formname, fields, sender)
|
|
if not utils.can_interact_with_node (pos, sender) then
|
|
return
|
|
end
|
|
|
|
local meta = minetest.get_meta (pos)
|
|
|
|
if meta then
|
|
if fields.submit then
|
|
meta:set_string ("channel", fields.channel)
|
|
end
|
|
|
|
if fields.single then
|
|
if fields.single == "true" then
|
|
local spec =
|
|
"size[7,3.3]"..
|
|
"field[1,1;4,2;channel;Channel;${channel}]"..
|
|
"button_exit[4.6,1.15;1.5,1;submit;Set]"..
|
|
"checkbox[1,2;single;Single move;true]"
|
|
|
|
meta:set_int ("max_extent", 1)
|
|
meta:set_string ("formspec", spec)
|
|
else
|
|
local spec =
|
|
"size[7,3.3]"..
|
|
"field[1,1;4,2;channel;Channel;${channel}]"..
|
|
"button_exit[4.6,1.15;1.5,1;submit;Set]"..
|
|
"checkbox[1,2;single;Single move;false]"
|
|
|
|
meta:set_int ("max_extent", 2)
|
|
meta:set_string ("formspec", spec)
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
|
|
|
|
local function on_blast (pos, intensity)
|
|
local meta = minetest.get_meta (pos)
|
|
|
|
if meta then
|
|
if intensity >= 1.0 then
|
|
|
|
minetest.remove_node (pos)
|
|
|
|
else -- intensity < 1.0
|
|
|
|
local node = minetest.get_node_or_nil (pos)
|
|
if node then
|
|
local items = minetest.get_node_drops (node, nil)
|
|
|
|
if items and #items > 0 then
|
|
local stack = ItemStack (items[1])
|
|
|
|
if stack then
|
|
utils.item_drop (stack, nil, pos)
|
|
minetest.remove_node (pos)
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
|
|
|
|
local function can_dig (pos, player)
|
|
if not utils.can_interact_with_node (pos, player) then
|
|
return false
|
|
end
|
|
|
|
return true
|
|
end
|
|
|
|
|
|
|
|
local function on_rightclick (pos, node, clicker, itemstack, pointed_thing)
|
|
if not utils.can_interact_with_node (pos, clicker) then
|
|
if clicker and clicker:is_player () then
|
|
local owner = "<unknown>"
|
|
local meta = minetest.get_meta (pos)
|
|
|
|
if meta then
|
|
owner = meta:get_string ("owner")
|
|
end
|
|
|
|
local spec =
|
|
"formspec_version[3]"..
|
|
"size[8.0,4.0,false]"..
|
|
"label[1.0,1.0;Owned by "..minetest.formspec_escape (owner).."]"..
|
|
"button_exit[3.0,2.0;2.0,1.0;close;Close]"
|
|
|
|
minetest.show_formspec (clicker:get_player_name (),
|
|
"lwcomponents:component_privately_owned",
|
|
spec)
|
|
end
|
|
end
|
|
|
|
return itemstack
|
|
end
|
|
|
|
|
|
|
|
local function on_timer (pos, elapsed)
|
|
local meta = minetest.get_meta (pos)
|
|
|
|
if meta then
|
|
return extend_piston (pos, meta:get_int ("extent"))
|
|
end
|
|
|
|
return false
|
|
end
|
|
|
|
|
|
|
|
local function digilines_support ()
|
|
if utils.digilines_supported then
|
|
return
|
|
{
|
|
wire =
|
|
{
|
|
rules = utils.digilines_default_rules,
|
|
},
|
|
|
|
effector =
|
|
{
|
|
action = function (pos, node, channel, msg)
|
|
local meta = minetest.get_meta(pos)
|
|
|
|
if meta then
|
|
local this_channel = meta:get_string ("channel")
|
|
|
|
if this_channel ~= "" and this_channel == channel then
|
|
if type (msg) == "string" then
|
|
local m = { }
|
|
for w in string.gmatch(msg, "[^%s]+") do
|
|
m[#m + 1] = w
|
|
end
|
|
|
|
if m[1] == "extend" then
|
|
extend_piston (pos, m[2])
|
|
|
|
elseif m[1] == "retract" then
|
|
extend_piston (pos, 0)
|
|
|
|
elseif m[1] == "single" then
|
|
local spec =
|
|
"size[7,3.3]"..
|
|
"field[1,1;4,2;channel;Channel;${channel}]"..
|
|
"button_exit[4.6,1.15;1.5,1;submit;Set]"..
|
|
"checkbox[1,2;single;Single move;true]"
|
|
|
|
meta:set_int ("max_extent", 1)
|
|
meta:set_string ("formspec", spec)
|
|
|
|
elseif m[1] == "double" then
|
|
local spec =
|
|
"size[7,3.3]"..
|
|
"field[1,1;4,2;channel;Channel;${channel}]"..
|
|
"button_exit[4.6,1.15;1.5,1;submit;Set]"..
|
|
"checkbox[1,2;single;Single move;false]"
|
|
|
|
meta:set_int ("max_extent", 2)
|
|
meta:set_string ("formspec", spec)
|
|
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end,
|
|
}
|
|
}
|
|
end
|
|
|
|
return nil
|
|
end
|
|
|
|
|
|
|
|
local function mesecon_support ()
|
|
if utils.mesecon_supported then
|
|
return
|
|
{
|
|
effector =
|
|
{
|
|
rules = function (node)
|
|
local dir = vector.multiply (minetest.facedir_to_dir (node.param2), -1)
|
|
local rules = table.copy (utils.mesecon_default_rules)
|
|
|
|
for i = #rules, 1, -1 do
|
|
if vector.equals (rules[i], dir) then
|
|
table.remove (rules, i)
|
|
end
|
|
end
|
|
|
|
return rules
|
|
end,
|
|
|
|
action_on = function (pos, node)
|
|
-- do something to turn the effector on
|
|
extend_piston (pos, 2)
|
|
end,
|
|
|
|
action_off = function (pos, node)
|
|
-- do something to turn the effector off
|
|
extend_piston (pos, 0)
|
|
end,
|
|
}
|
|
}
|
|
end
|
|
|
|
return nil
|
|
end
|
|
|
|
|
|
|
|
minetest.register_node("lwcomponents:piston_blank_1", {
|
|
description = S("Piston blank"),
|
|
drawtype = "airlike",
|
|
light_source = 0,
|
|
sunlight_propagates = true,
|
|
walkable = false,
|
|
pointable = false,
|
|
diggable = false,
|
|
climbable = false,
|
|
buildable_to = false,
|
|
floodable = false,
|
|
is_ground_content = false,
|
|
drop = "",
|
|
groups = { not_in_creative_inventory = 1 },
|
|
paramtype = "light",
|
|
-- unaffected by explosions
|
|
on_blast = function() end,
|
|
})
|
|
|
|
|
|
|
|
minetest.register_node("lwcomponents:piston_blank_2", {
|
|
description = S("Piston blank"),
|
|
drawtype = "airlike",
|
|
paramtype = "light",
|
|
param1 = 0,
|
|
paramtype2 = "facedir",
|
|
param2 = 0,
|
|
collision_box = {
|
|
type = "fixed",
|
|
fixed = {
|
|
{-0.125, -0.125, -0.4, 0.125, 0.125, 0.4},
|
|
{-0.5, -0.5, -0.5, 0.5, 0.5, -0.3125},
|
|
},
|
|
},
|
|
light_source = 0,
|
|
sunlight_propagates = true,
|
|
walkable = true,
|
|
pointable = false,
|
|
diggable = false,
|
|
climbable = false,
|
|
buildable_to = false,
|
|
floodable = false,
|
|
is_ground_content = false,
|
|
drop = "",
|
|
groups = { not_in_creative_inventory = 1 },
|
|
-- unaffected by explosions
|
|
on_blast = function() end,
|
|
})
|
|
|
|
|
|
|
|
minetest.register_node("lwcomponents:piston", {
|
|
description = S("Double Piston"),
|
|
tiles = { "lwcomponents_piston_top.png", "lwcomponents_piston_bottom.png",
|
|
"lwcomponents_piston_right.png", "lwcomponents_piston_left.png",
|
|
"lwcomponents_piston_base.png", "lwcomponents_piston_pusher.png" },
|
|
is_ground_content = false,
|
|
groups = { cracky = 3, wires_connect = 1 },
|
|
sounds = default.node_sound_stone_defaults (),
|
|
paramtype = "light",
|
|
param1 = 0,
|
|
paramtype2 = "facedir",
|
|
param2 = 0,
|
|
floodable = false,
|
|
drop = "lwcomponents:piston",
|
|
_digistuff_channelcopier_fieldname = "channel",
|
|
|
|
mesecons = mesecon_support (),
|
|
digiline = digilines_support (),
|
|
|
|
on_place = on_place,
|
|
on_receive_fields = on_receive_fields,
|
|
can_dig = can_dig,
|
|
after_place_node = after_place_node,
|
|
on_blast = on_blast,
|
|
on_rightclick = on_rightclick,
|
|
on_timer = on_timer
|
|
})
|
|
|
|
|
|
|
|
minetest.register_node("lwcomponents:piston_1", {
|
|
description = S("Double Piston"),
|
|
drawtype = "mesh",
|
|
mesh = "piston_normal_1.obj",
|
|
tiles = { "lwcomponents_piston.png" },
|
|
visual_scale = 1.0,
|
|
selection_box = {
|
|
type = "fixed",
|
|
fixed = {
|
|
{-0.125, -0.125, -1.4, 0.125, 0.125, 0.4},
|
|
{-0.5, -0.5, -1.5, 0.5, 0.5, -1.3125},
|
|
{-0.5, -0.5, -0.3125, 0.5, 0.5, 0.5},
|
|
},
|
|
},
|
|
collision_box = {
|
|
type = "fixed",
|
|
fixed = {
|
|
{-0.125, -0.125, -1.4, 0.125, 0.125, 0.4},
|
|
{-0.5, -0.5, -1.5, 0.5, 0.5, -1.3125},
|
|
{-0.5, -0.5, -0.3125, 0.5, 0.5, 0.5},
|
|
},
|
|
},
|
|
is_ground_content = false,
|
|
groups = { cracky = 3 , not_in_creative_inventory = 1, wires_connect = 1 },
|
|
sounds = default.node_sound_stone_defaults (),
|
|
paramtype = "light",
|
|
param1 = 0,
|
|
paramtype2 = "facedir",
|
|
param2 = 0,
|
|
floodable = false,
|
|
drop = "lwcomponents:piston",
|
|
_digistuff_channelcopier_fieldname = "channel",
|
|
|
|
mesecons = mesecon_support (),
|
|
digiline = digilines_support (),
|
|
|
|
on_destruct = on_destruct_1,
|
|
on_receive_fields = on_receive_fields,
|
|
can_dig = can_dig,
|
|
after_place_node = after_place_node,
|
|
on_blast = on_blast,
|
|
on_rightclick = on_rightclick,
|
|
on_timer = on_timer
|
|
})
|
|
|
|
|
|
|
|
minetest.register_node("lwcomponents:piston_2", {
|
|
description = S("Double Piston"),
|
|
drawtype = "mesh",
|
|
mesh = "piston_normal_2.obj",
|
|
tiles = { "lwcomponents_piston.png" },
|
|
visual_scale = 1.0,
|
|
selection_box = {
|
|
type = "fixed",
|
|
fixed = {
|
|
{-0.125, -0.125, -2.4, 0.125, 0.125, 0.4},
|
|
{-0.5, -0.5, -2.5, 0.5, 0.5, -2.3125},
|
|
{-0.5, -0.5, -0.3125, 0.5, 0.5, 0.5},
|
|
},
|
|
},
|
|
collision_box = {
|
|
type = "fixed",
|
|
fixed = {
|
|
{-0.125, -0.125, -2.4, 0.125, 0.125, 0.4},
|
|
{-0.5, -0.5, -2.5, 0.5, 0.5, -2.3125},
|
|
{-0.5, -0.5, -0.3125, 0.5, 0.5, 0.5},
|
|
},
|
|
},
|
|
is_ground_content = false,
|
|
groups = { cracky = 3 , not_in_creative_inventory = 1, wires_connect = 1 },
|
|
sounds = default.node_sound_stone_defaults (),
|
|
paramtype = "light",
|
|
param1 = 0,
|
|
paramtype2 = "facedir",
|
|
param2 = 0,
|
|
floodable = false,
|
|
drop = "lwcomponents:piston",
|
|
_digistuff_channelcopier_fieldname = "channel",
|
|
|
|
mesecons = mesecon_support (),
|
|
digiline = digilines_support (),
|
|
|
|
on_destruct = on_destruct_2,
|
|
on_receive_fields = on_receive_fields,
|
|
can_dig = can_dig,
|
|
after_place_node = after_place_node,
|
|
on_blast = on_blast,
|
|
on_rightclick = on_rightclick,
|
|
on_timer = on_timer
|
|
})
|
|
|
|
|
|
|
|
minetest.register_node("lwcomponents:piston_sticky", {
|
|
description = S("Double Sticky Piston"),
|
|
tiles = { "lwcomponents_piston_top.png", "lwcomponents_piston_bottom.png",
|
|
"lwcomponents_piston_right.png", "lwcomponents_piston_left.png",
|
|
"lwcomponents_piston_base.png", "lwcomponents_piston_pusher_sticky.png" },
|
|
is_ground_content = false,
|
|
groups = { cracky = 3, wires_connect = 1 },
|
|
sounds = default.node_sound_stone_defaults (),
|
|
paramtype = "light",
|
|
param1 = 0,
|
|
paramtype2 = "facedir",
|
|
param2 = 0,
|
|
floodable = false,
|
|
drop = "lwcomponents:piston_sticky",
|
|
_digistuff_channelcopier_fieldname = "channel",
|
|
|
|
mesecons = mesecon_support (),
|
|
digiline = digilines_support (),
|
|
|
|
on_place = on_place,
|
|
on_receive_fields = on_receive_fields,
|
|
can_dig = can_dig,
|
|
after_place_node = after_place_node,
|
|
on_blast = on_blast,
|
|
on_rightclick = on_rightclick,
|
|
on_timer = on_timer
|
|
})
|
|
|
|
|
|
|
|
minetest.register_node("lwcomponents:piston_sticky_1", {
|
|
description = S("Double Sticky Piston"),
|
|
drawtype = "mesh",
|
|
mesh = "piston_sticky_1.obj",
|
|
tiles = { "lwcomponents_piston.png" },
|
|
visual_scale = 1.0,
|
|
selection_box = {
|
|
type = "fixed",
|
|
fixed = {
|
|
{-0.125, -0.125, -1.4, 0.125, 0.125, 0.4},
|
|
{-0.5, -0.5, -1.5, 0.5, 0.5, -1.3125},
|
|
{-0.5, -0.5, -0.3125, 0.5, 0.5, 0.5},
|
|
},
|
|
},
|
|
collision_box = {
|
|
type = "fixed",
|
|
fixed = {
|
|
{-0.125, -0.125, -1.4, 0.125, 0.125, 0.4},
|
|
{-0.5, -0.5, -1.5, 0.5, 0.5, -1.3125},
|
|
{-0.5, -0.5, -0.3125, 0.5, 0.5, 0.5},
|
|
},
|
|
},
|
|
is_ground_content = false,
|
|
groups = { cracky = 3 , not_in_creative_inventory = 1, wires_connect = 1 },
|
|
sounds = default.node_sound_stone_defaults (),
|
|
paramtype = "light",
|
|
param1 = 0,
|
|
paramtype2 = "facedir",
|
|
param2 = 0,
|
|
floodable = false,
|
|
drop = "lwcomponents:piston_sticky",
|
|
_digistuff_channelcopier_fieldname = "channel",
|
|
|
|
mesecons = mesecon_support (),
|
|
digiline = digilines_support (),
|
|
|
|
on_destruct = on_destruct_1,
|
|
on_receive_fields = on_receive_fields,
|
|
can_dig = can_dig,
|
|
after_place_node = after_place_node,
|
|
on_blast = on_blast,
|
|
on_rightclick = on_rightclick,
|
|
on_timer = on_timer
|
|
})
|
|
|
|
|
|
|
|
minetest.register_node("lwcomponents:piston_sticky_2", {
|
|
description = S("Double Sticky Piston"),
|
|
drawtype = "mesh",
|
|
mesh = "piston_sticky_2.obj",
|
|
tiles = { "lwcomponents_piston.png" },
|
|
visual_scale = 1.0,
|
|
selection_box = {
|
|
type = "fixed",
|
|
fixed = {
|
|
{-0.125, -0.125, -2.4, 0.125, 0.125, 0.4},
|
|
{-0.5, -0.5, -2.5, 0.5, 0.5, -2.3125},
|
|
{-0.5, -0.5, -0.3125, 0.5, 0.5, 0.5},
|
|
},
|
|
},
|
|
collision_box = {
|
|
type = "fixed",
|
|
fixed = {
|
|
{-0.125, -0.125, -2.4, 0.125, 0.125, 0.4},
|
|
{-0.5, -0.5, -2.5, 0.5, 0.5, -2.3125},
|
|
{-0.5, -0.5, -0.3125, 0.5, 0.5, 0.5},
|
|
},
|
|
},
|
|
is_ground_content = false,
|
|
groups = { cracky = 3 , not_in_creative_inventory = 1, wires_connect = 1 },
|
|
sounds = default.node_sound_stone_defaults (),
|
|
paramtype = "light",
|
|
param1 = 0,
|
|
paramtype2 = "facedir",
|
|
param2 = 0,
|
|
floodable = false,
|
|
drop = "lwcomponents:piston_sticky",
|
|
_digistuff_channelcopier_fieldname = "channel",
|
|
|
|
mesecons = mesecon_support (),
|
|
digiline = digilines_support (),
|
|
|
|
on_destruct = on_destruct_2,
|
|
on_receive_fields = on_receive_fields,
|
|
can_dig = can_dig,
|
|
after_place_node = after_place_node,
|
|
on_blast = on_blast,
|
|
on_rightclick = on_rightclick,
|
|
on_timer = on_timer
|
|
})
|
|
|
|
|
|
|
|
end -- utils.digilines_supported or utils.mesecon_supported
|