mirror of
https://github.com/joe7575/techpack.git
synced 2024-09-12 07:58:39 +02:00
441 lines
13 KiB
Lua
441 lines
13 KiB
Lua
--[[
|
|
|
|
Tube Library
|
|
============
|
|
|
|
Copyright (C) 2017 Joachim Stolberg
|
|
|
|
LGPLv2.1+
|
|
See LICENSE.txt for more information
|
|
|
|
History:
|
|
see init.lua
|
|
|
|
]]--
|
|
|
|
|
|
local MAX_TUBE_LENGTH = 100
|
|
|
|
local TubeTypes = {
|
|
0,0,0,0,0,0,1,3,1,3, -- 01-10
|
|
4,5,3,1,3,1,4,5,1,3, -- 11-20
|
|
1,3,4,5,3,1,3,1,4,5, -- 21-30
|
|
2,2,2,2,0,2,2,2,5,2, -- 31-40
|
|
5,0, -- 40-41
|
|
}
|
|
|
|
local TubeFacedir = {
|
|
0,0,0,0,0,0,0,2,0,1, -- 01-10
|
|
2,2,2,1,3,1,3,3,0,3, -- 11-20
|
|
0,0,0,0,1,1,0,1,1,1, -- 21-30
|
|
0,0,0,0,0,0,0,0,0,0, -- 31-40
|
|
0,0, -- 40-41
|
|
}
|
|
|
|
tubelib.knownNodes = {
|
|
["tubelib:tube1"] = true,
|
|
["tubelib:tube2"] = true,
|
|
["tubelib:tube3"] = true,
|
|
["tubelib:tube4"] = true,
|
|
["tubelib:tube5"] = true,
|
|
["tubelib:tube6"] = true,
|
|
["default:chest_locked"] = true,
|
|
["default:chest"] = true,
|
|
["default:furnace"] = true,
|
|
["default:furnace_active"] = true,
|
|
}
|
|
|
|
-- Localize functions to avoid table lookups (better performance).
|
|
local string_find = string.find
|
|
local minetest_get_meta = minetest.get_meta
|
|
local minetest_get_node = minetest.get_node
|
|
local KnownNodes = tubelib.knownNodes
|
|
local vector_add = vector.add
|
|
local vector_equals = vector.equals
|
|
|
|
-- Translate from contact side to facedir
|
|
local SideToFacedir = {B=0, R=1, F=2, L=3, D=4, U=5}
|
|
|
|
-- 6D variant of the facedir to dir conversion
|
|
local Facedir2Dir = {[0] =
|
|
{x=0, y=0, z=1},
|
|
{x=1, y=0, z=0},
|
|
{x=0, y=0, z=-1},
|
|
{x=-1, y=0, z=0},
|
|
{x=0, y=-1, z=0},
|
|
{x=0, y=1, z=0},
|
|
}
|
|
|
|
-- Determine position from and facedir to the node on the other side or the tubes.
|
|
-- Param pos: my pos
|
|
-- Param npos: neighbor tube pos
|
|
local function remote_node(pos, npos)
|
|
local dest_pos = minetest.string_to_pos(minetest.get_meta(npos):get_string("dest_pos"))
|
|
-- two possible reasons, why dest_pos == pos:
|
|
-- 1) wrong side of a single tube node
|
|
-- 2) node connected with itself. In this case "dest_pos2" is not available
|
|
if dest_pos and vector_equals(dest_pos, pos) then
|
|
local dest_pos2 = minetest.string_to_pos(minetest.get_meta(npos):get_string("dest_pos2"))
|
|
if dest_pos2 == nil then
|
|
local facedir = minetest.get_meta(npos):get_int("facedir")
|
|
return pos, facedir -- node connected with itself
|
|
else
|
|
local facedir2 = minetest.get_meta(npos):get_int("facedir2")
|
|
return dest_pos2, facedir2 -- one tube connection
|
|
end
|
|
else
|
|
local facedir = minetest.get_meta(npos):get_int("facedir")
|
|
return dest_pos, facedir -- multi tube connection
|
|
end
|
|
end
|
|
|
|
|
|
-- Calculate the facedir to the other node, based on both node positions
|
|
local function dir_to_facedir(my_pos, other_pos)
|
|
if my_pos.z ~= other_pos.z then return my_pos.z - other_pos.z + 1 end
|
|
if my_pos.x ~= other_pos.x then return my_pos.x - other_pos.x + 2 end
|
|
if my_pos.y > other_pos.y then return 5 else return 4 end
|
|
end
|
|
|
|
-------------------------------------------------------------------------------
|
|
-- API functions
|
|
-------------------------------------------------------------------------------
|
|
|
|
-- Determine neighbor position and own facedir to the node.
|
|
-- based on own pos and contact side 'B' - 'U'.
|
|
-- Function considers also tube connections.
|
|
function tubelib.get_neighbor_pos(pos, side)
|
|
local facedir = SideToFacedir[side]
|
|
if facedir < 4 then
|
|
local node = minetest_get_node(pos)
|
|
facedir = (facedir + node.param2) % 4
|
|
end
|
|
local npos = vector_add(pos, Facedir2Dir[facedir])
|
|
local node = minetest_get_node(npos)
|
|
if node and string_find(node.name, "tubelib:tube") then
|
|
npos, facedir = remote_node(pos, npos)
|
|
end
|
|
return npos, facedir
|
|
end
|
|
|
|
-- use Voxel Manipulator to read the node
|
|
function tubelib.read_node_with_vm(pos)
|
|
local vm = VoxelManip()
|
|
local MinEdge, MaxEdge = vm:read_from_map(pos, pos)
|
|
local data = vm:get_data()
|
|
local param2_data = vm:get_param2_data()
|
|
local area = VoxelArea:new({MinEdge = MinEdge, MaxEdge = MaxEdge})
|
|
return {
|
|
name=minetest.get_name_from_content_id(data[area:index(pos.x, pos.y, pos.z)]),
|
|
param2 = param2_data[area:index(pos.x, pos.y, pos.z)]
|
|
}
|
|
end
|
|
|
|
local read_node_with_vm = tubelib.read_node_with_vm
|
|
|
|
-------------------------------------------------------------------------------
|
|
-- Tube placement
|
|
-------------------------------------------------------------------------------
|
|
|
|
|
|
-- Return neighbor tubes orientation relative to the given pos.
|
|
local function get_neighbor_tubes_orientation(pos)
|
|
local orientation = 0
|
|
local Nodes = {
|
|
minetest.get_node({x=pos.x , y=pos.y , z=pos.z+1}),
|
|
minetest.get_node({x=pos.x+1, y=pos.y , z=pos.z }),
|
|
minetest.get_node({x=pos.x , y=pos.y , z=pos.z-1}),
|
|
minetest.get_node({x=pos.x-1, y=pos.y , z=pos.z }),
|
|
minetest.get_node({x=pos.x , y=pos.y-1, z=pos.z }),
|
|
minetest.get_node({x=pos.x , y=pos.y+1, z=pos.z }),
|
|
}
|
|
for side,node in ipairs(Nodes) do
|
|
if KnownNodes[node.name] then -- registered node?
|
|
orientation = orientation * 6 + side
|
|
if orientation > 6 then
|
|
break
|
|
end
|
|
end
|
|
end
|
|
return orientation
|
|
end
|
|
|
|
local function determine_tube_node(pos)
|
|
local node = minetest.get_node(pos)
|
|
if not string.find(node.name, "tubelib:tube") then
|
|
return nil
|
|
end
|
|
local orientation = get_neighbor_tubes_orientation(pos)
|
|
if orientation > 6 then
|
|
node.name = "tubelib:tube"..TubeTypes[orientation]
|
|
node.param2 = TubeFacedir[orientation]
|
|
return node
|
|
elseif orientation > 0 then
|
|
orientation = orientation * 6 + (((node.param2 + 2) % 4) + 1)
|
|
node.name = "tubelib:tube"..TubeTypes[orientation]
|
|
node.param2 = TubeFacedir[orientation]
|
|
return node
|
|
end
|
|
return nil
|
|
end
|
|
|
|
|
|
local function update_tube(pos)
|
|
local node = determine_tube_node(pos)
|
|
if node then
|
|
minetest.swap_node(pos, node)
|
|
end
|
|
end
|
|
|
|
local OffsTable = {
|
|
{2,0}, -- tube1
|
|
{4,5}, -- tube2
|
|
{2,3}, -- tube3
|
|
{2,4}, -- tube4
|
|
{2,5}, -- tube5
|
|
}
|
|
|
|
|
|
-- The tube on 'pos1' has two ends and thus two neighbor position.
|
|
-- One is the given 'pos', the other position is returned.
|
|
-- Param mpos: my node position
|
|
-- Param opos: the other tube position
|
|
-- Param node: the tube node
|
|
local function nodetype_to_pos(mpos, opos, node)
|
|
local idx = string.byte(node.name, -1) - 48
|
|
local facedir1 = OffsTable[idx][1]
|
|
local facedir2 = OffsTable[idx][2]
|
|
if facedir1 < 4 then
|
|
facedir1 = (facedir1 + node.param2) % 4
|
|
end
|
|
if facedir2 < 4 then
|
|
facedir2 = (facedir2 + node.param2) % 4
|
|
end
|
|
local dir1 = Facedir2Dir[facedir1]
|
|
local dir2 = Facedir2Dir[facedir2]
|
|
local p1 = vector.add(opos, dir1)
|
|
local p2 = vector.add(opos, dir2)
|
|
|
|
if mpos == nil then
|
|
return p1, p2
|
|
elseif vector.equals(p1, mpos) then
|
|
return p2
|
|
else
|
|
return p1
|
|
end
|
|
end
|
|
|
|
|
|
-- Walk to the other end of the tube line, starting at 'pos1'.
|
|
-- Returns: cnt - number of tube nodes
|
|
-- pos - the peer tube node
|
|
-- pos1 - the destination position, connected with 'pos'
|
|
local function walk_to_peer(pos, pos1)
|
|
local node = minetest.get_node(pos1)
|
|
local pos2
|
|
local cnt = 0
|
|
while string.find(node.name, "tubelib:tube") and cnt < MAX_TUBE_LENGTH do
|
|
pos2 = nodetype_to_pos(pos, pos1, node)
|
|
pos, pos1 = pos1, pos2
|
|
cnt = cnt + 1
|
|
node = minetest.get_node_or_nil(pos1) or read_node_with_vm(pos1)
|
|
end
|
|
return cnt, pos, pos1
|
|
end
|
|
|
|
-- Update head tubes with peer pos and facedir of the other end
|
|
-- Needed for StackItem exchange.
|
|
local function update_head_tubes(pos)
|
|
local node = minetest.get_node(pos)
|
|
if string.find(node.name, "tubelib:tube") then
|
|
local pos1, pos2 = nodetype_to_pos(nil, pos, node)
|
|
local cnt1, peer1, dest1 = walk_to_peer(pos, pos1)
|
|
local cnt2, peer2, dest2 = walk_to_peer(pos, pos2)
|
|
|
|
if cnt1 == 0 and cnt2 == 0 then -- first tube node placed?
|
|
-- we have to store both dest positions
|
|
minetest.get_meta(peer1):set_string("dest_pos", minetest.pos_to_string(dest1))
|
|
minetest.get_meta(peer1):set_int("facedir", dir_to_facedir(peer1, dest1))
|
|
minetest.get_meta(peer1):set_string("dest_pos2", minetest.pos_to_string(dest2))
|
|
minetest.get_meta(peer1):set_int("facedir2", dir_to_facedir(peer2, dest2))
|
|
else
|
|
minetest.get_meta(peer1):set_string("dest_pos", minetest.pos_to_string(dest2))
|
|
minetest.get_meta(peer1):set_int("facedir", dir_to_facedir(peer2, dest2))
|
|
minetest.get_meta(peer2):set_string("dest_pos", minetest.pos_to_string(dest1))
|
|
minetest.get_meta(peer2):set_int("facedir", dir_to_facedir(peer1, dest1))
|
|
end
|
|
|
|
-- delete meta data from old head nodes
|
|
if cnt1 > 1 then
|
|
minetest.get_meta(pos1):from_table(nil)
|
|
end
|
|
if cnt2 > 1 then
|
|
minetest.get_meta(pos2):from_table(nil)
|
|
end
|
|
return cnt1 + cnt2
|
|
end
|
|
return 0
|
|
end
|
|
|
|
-- Update all tubes arround the currently placed tube
|
|
local function update_surrounding_tubes(pos)
|
|
update_tube({x=pos.x , y=pos.y , z=pos.z+1})
|
|
update_tube({x=pos.x+1, y=pos.y , z=pos.z })
|
|
update_tube({x=pos.x , y=pos.y , z=pos.z-1})
|
|
update_tube({x=pos.x-1, y=pos.y , z=pos.z })
|
|
update_tube({x=pos.x , y=pos.y-1, z=pos.z })
|
|
update_tube({x=pos.x , y=pos.y+1, z=pos.z })
|
|
update_tube(pos)
|
|
return update_head_tubes(pos) < MAX_TUBE_LENGTH
|
|
end
|
|
|
|
|
|
-- Update tubes after a tube node is removed
|
|
local function after_tube_removed(pos, node)
|
|
local pos1, pos2 = nodetype_to_pos(nil, pos, node)
|
|
update_head_tubes(pos1)
|
|
update_head_tubes(pos2)
|
|
end
|
|
|
|
-- API function, called from all nodes, which shall be connected to tubes
|
|
function tubelib.update_tubes(pos)
|
|
update_tube( {x=pos.x , y=pos.y , z=pos.z+1})
|
|
update_head_tubes({x=pos.x , y=pos.y , z=pos.z+1})
|
|
update_tube( {x=pos.x+1, y=pos.y , z=pos.z })
|
|
update_head_tubes({x=pos.x+1, y=pos.y , z=pos.z })
|
|
update_tube( {x=pos.x , y=pos.y , z=pos.z-1})
|
|
update_head_tubes({x=pos.x , y=pos.y , z=pos.z-1})
|
|
update_tube( {x=pos.x-1, y=pos.y , z=pos.z })
|
|
update_head_tubes({x=pos.x-1, y=pos.y , z=pos.z })
|
|
update_tube( {x=pos.x , y=pos.y-1, z=pos.z })
|
|
update_head_tubes({x=pos.x , y=pos.y-1, z=pos.z })
|
|
update_tube( {x=pos.x , y=pos.y+1, z=pos.z })
|
|
update_head_tubes({x=pos.x , y=pos.y+1, z=pos.z })
|
|
end
|
|
|
|
local DefNodeboxes = {
|
|
-- x1 y1 z1 x2 y2 z2
|
|
{ -1/4, -1/4, -1/4, 1/4, 1/4, 1/4 },
|
|
{ -1/4, -1/4, -1/4, 1/4, 1/4, 1/4 },
|
|
}
|
|
|
|
local DirCorrections = {
|
|
{3, 6}, {2, 5}, -- standard tubes
|
|
{3, 1}, {3, 2}, {3, 5}, -- knees from front to..
|
|
}
|
|
|
|
local SelectBoxes = {
|
|
{ -1/4, -1/4, -1/2, 1/4, 1/4, 1/2 },
|
|
{ -1/4, -1/2, -1/4, 1/4, 1/2, 1/4 },
|
|
{ -1/2, -1/4, -1/2, 1/4, 1/4, 1/4 },
|
|
{ -1/4, -1/2, -1/2, 1/4, 1/4, 1/4 },
|
|
{ -1/4, -1/4, -1/2, 1/4, 1/2, 1/4 },
|
|
}
|
|
|
|
local TilesData = {
|
|
-- up, down, right, left, back, front
|
|
{
|
|
"tubelib_tube.png^[transformR90",
|
|
"tubelib_tube.png^[transformR90",
|
|
"tubelib_tube.png",
|
|
"tubelib_tube.png",
|
|
"tubelib_hole.png",
|
|
"tubelib_hole.png",
|
|
},
|
|
{
|
|
"tubelib_hole.png",
|
|
"tubelib_hole.png",
|
|
"tubelib_tube.png^[transformR90",
|
|
"tubelib_tube.png^[transformR90",
|
|
"tubelib_tube.png^[transformR90",
|
|
"tubelib_tube.png^[transformR90",
|
|
},
|
|
{
|
|
"tubelib_knee.png^[transformR270",
|
|
"tubelib_knee.png^[transformR180",
|
|
"tubelib_knee2.png^[transformR270",
|
|
"tubelib_hole2.png^[transformR90",
|
|
"tubelib_knee2.png^[transformR90",
|
|
"tubelib_hole2.png^[transformR270",
|
|
},
|
|
{
|
|
"tubelib_knee2.png",
|
|
"tubelib_hole2.png^[transformR180",
|
|
"tubelib_knee.png^[transformR270",
|
|
"tubelib_knee.png",
|
|
"tubelib_knee2.png",
|
|
"tubelib_hole2.png",
|
|
},
|
|
{
|
|
"tubelib_hole2.png",
|
|
"tubelib_knee2.png^[transformR180",
|
|
"tubelib_knee.png^[transformR180",
|
|
"tubelib_knee.png^[transformR90",
|
|
"tubelib_knee2.png^[transformR180",
|
|
"tubelib_hole2.png^[transformR180",
|
|
},
|
|
}
|
|
|
|
|
|
for idx,pos in ipairs(DirCorrections) do
|
|
node_box_data = table.copy(DefNodeboxes)
|
|
node_box_data[1][pos[1]] = node_box_data[1][pos[1]] * 2
|
|
node_box_data[2][pos[2]] = node_box_data[2][pos[2]] * 2
|
|
|
|
tiles_data = TilesData[idx]
|
|
|
|
if idx == 1 then
|
|
hidden = 0
|
|
else
|
|
hidden = 1
|
|
end
|
|
minetest.register_node("tubelib:tube"..idx, {
|
|
description = "Tubelib Tube",
|
|
tiles = tiles_data,
|
|
drawtype = "nodebox",
|
|
node_box = {
|
|
type = "fixed",
|
|
fixed = node_box_data,
|
|
},
|
|
selection_box = {
|
|
type = "fixed",
|
|
fixed = SelectBoxes[idx],
|
|
},
|
|
collision_box = {
|
|
type = "fixed",
|
|
fixed = SelectBoxes[idx],
|
|
},
|
|
|
|
after_place_node = function(pos, placer, itemstack, pointed_thing)
|
|
if update_surrounding_tubes(pos) == false then
|
|
after_tube_removed(pos, minetest.get_node(pos))
|
|
minetest.remove_node(pos)
|
|
return itemstack
|
|
end
|
|
end,
|
|
|
|
after_dig_node = function(pos, oldnode, oldmetadata, digger)
|
|
after_tube_removed(pos, oldnode)
|
|
end,
|
|
|
|
on_rotate = screwdriver.disallow,
|
|
paramtype2 = "facedir",
|
|
paramtype = "light",
|
|
sunlight_propagates = true,
|
|
is_ground_content = false,
|
|
groups = {choppy=2, cracky=3, stone=1, not_in_creative_inventory=hidden},
|
|
drop = "tubelib:tube1",
|
|
sounds = default.node_sound_wood_defaults(),
|
|
})
|
|
end
|
|
|
|
|
|
minetest.register_craft({
|
|
output = "tubelib:tube1 4",
|
|
recipe = {
|
|
{"default:steel_ingot", "", "group:wood"},
|
|
{"", "group:wood", ""},
|
|
{"group:wood", "", "default:tin_ingot"},
|
|
},
|
|
})
|