summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
authororwell96 <orwell@bleipb.de>2018-12-19 17:16:13 +0100
committerorwell96 <orwell@bleipb.de>2018-12-19 17:16:13 +0100
commit2ff8f5fd4649cff554cc6afab3d92ac7efedb809 (patch)
tree71d983033c622695f4e8dc4ab959bef5cdce5549
downloadadvtrains_netmapper-2ff8f5fd4649cff554cc6afab3d92ac7efedb809.zip
advtrains_netmapper-2ff8f5fd4649cff554cc6afab3d92ac7efedb809.tar.gz
advtrains_netmapper-2ff8f5fd4649cff554cc6afab3d92ac7efedb809.tar.bz2
Initial version
-rw-r--r--helpers.lua431
-rw-r--r--main.lua230
-rw-r--r--nodedb.lua163
-rwxr-xr-xserialize.lua221
-rw-r--r--track_defs.lua152
-rw-r--r--tracks.lua265
-rwxr-xr-xvector.lua145
7 files changed, 1607 insertions, 0 deletions
diff --git a/helpers.lua b/helpers.lua
new file mode 100644
index 0000000..511d32e
--- /dev/null
+++ b/helpers.lua
@@ -0,0 +1,431 @@
+--advtrains by orwell96, see readme.txt
+
+local dir_trans_tbl={
+ [0]={x=0, z=1, y=0},
+ [1]={x=1, z=2, y=0},
+ [2]={x=1, z=1, y=0},
+ [3]={x=2, z=1, y=0},
+ [4]={x=1, z=0, y=0},
+ [5]={x=2, z=-1, y=0},
+ [6]={x=1, z=-1, y=0},
+ [7]={x=1, z=-2, y=0},
+ [8]={x=0, z=-1, y=0},
+ [9]={x=-1, z=-2, y=0},
+ [10]={x=-1, z=-1, y=0},
+ [11]={x=-2, z=-1, y=0},
+ [12]={x=-1, z=0, y=0},
+ [13]={x=-2, z=1, y=0},
+ [14]={x=-1, z=1, y=0},
+ [15]={x=-1, z=2, y=0},
+}
+
+local dir_angle_tbl={}
+for d,v in pairs(dir_trans_tbl) do
+ local uvec = vector.normalize(v)
+ dir_angle_tbl[d] = math.atan2(-uvec.x, uvec.z)
+end
+
+
+function advtrains.dir_to_angle(dir)
+ return dir_angle_tbl[dir] or error("advtrains: in helpers.lua/dir_to_angle() given dir="..(dir or "nil"))
+end
+
+function advtrains.dirCoordSet(coord, dir)
+ return vector.add(coord, advtrains.dirToCoord(dir))
+end
+advtrains.pos_add_dir = advtrains.dirCoordSet
+
+function advtrains.pos_add_angle(pos, ang)
+ -- 0 is +Z -> meaning of sin/cos swapped
+ return vector.add(pos, {x = -math.sin(ang), y = 0, z = math.cos(ang)})
+end
+
+function advtrains.dirToCoord(dir)
+ return dir_trans_tbl[dir] or error("advtrains: in helpers.lua/dir_to_vector() given dir="..(dir or "nil"))
+end
+advtrains.dir_to_vector = advtrains.dirToCoord
+
+function advtrains.maxN(list, expectstart)
+ local n=expectstart or 0
+ while list[n] do
+ n=n+1
+ end
+ return n-1
+end
+
+function advtrains.minN(list, expectstart)
+ local n=expectstart or 0
+ while list[n] do
+ n=n-1
+ end
+ return n+1
+end
+
+function atround(number)
+ return math.floor(number+0.5)
+end
+atfloor = math.floor
+
+
+function advtrains.round_vector_floor_y(vec)
+ return {x=math.floor(vec.x+0.5), y=math.floor(vec.y), z=math.floor(vec.z+0.5)}
+end
+
+function advtrains.yawToDirection(yaw, conn1, conn2)
+ if not conn1 or not conn2 then
+ error("given nil to yawToDirection: conn1="..(conn1 or "nil").." conn2="..(conn1 or "nil"))
+ end
+ local yaw1 = advtrains.dir_to_angle(conn1)
+ local yaw2 = advtrains.dir_to_angle(conn2)
+ local adiff1 = advtrains.minAngleDiffRad(yaw, yaw1)
+ local adiff2 = advtrains.minAngleDiffRad(yaw, yaw2)
+
+ if math.abs(adiff2)<math.abs(adiff1) then
+ return conn2
+ else
+ return conn1
+ end
+end
+
+function advtrains.yawToAnyDir(yaw)
+ local min_conn, min_diff=0, 10
+ for conn, vec in pairs(advtrains.dir_trans_tbl) do
+ local yaw1 = advtrains.dir_to_angle(conn)
+ local diff = math.abs(advtrains.minAngleDiffRad(yaw, yaw1))
+ if diff < min_diff then
+ min_conn = conn
+ min_diff = diff
+ end
+ end
+ return min_conn
+end
+function advtrains.yawToClosestConn(yaw, conns)
+ local min_connid, min_diff=1, 10
+ for connid, conn in ipairs(conns) do
+ local yaw1 = advtrains.dir_to_angle(conn.c)
+ local diff = math.abs(advtrains.minAngleDiffRad(yaw, yaw1))
+ if diff < min_diff then
+ min_connid = connid
+ min_diff = diff
+ end
+ end
+ return min_connid
+end
+
+local pi, pi2 = math.pi, 2*math.pi
+function advtrains.minAngleDiffRad(r1, r2)
+ while r1>pi2 do
+ r1=r1-pi2
+ end
+ while r1<0 do
+ r1=r1+pi2
+ end
+ while r2>pi2 do
+ r2=r2-pi2
+ end
+ while r1<0 do
+ r2=r2+pi2
+ end
+ local try1=r2-r1
+ local try2=r2+pi2-r1
+ local try3=r2-pi2-r1
+
+ local minabs = math.min(math.abs(try1), math.abs(try2), math.abs(try3))
+ if minabs==math.abs(try1) then
+ return try1
+ end
+ if minabs==math.abs(try2) then
+ return try2
+ end
+ if minabs==math.abs(try3) then
+ return try3
+ end
+end
+
+
+-- Takes 2 connections (0...AT_CMAX) as argument
+-- Returns the angle median of those 2 positions from the pov
+-- of standing on the cdir1 side and looking towards cdir2
+-- cdir1 - >NODE> - cdir2
+function advtrains.conn_angle_median(cdir1, cdir2)
+ local ang1 = advtrains.dir_to_angle(advtrains.oppd(cdir1))
+ local ang2 = advtrains.dir_to_angle(cdir2)
+ return ang1 + advtrains.minAngleDiffRad(ang1, ang2)/2
+end
+
+function advtrains.merge_tables(a, ...)
+ local new={}
+ for _,t in ipairs({a,...}) do
+ for k,v in pairs(t) do new[k]=v end
+ end
+ return new
+end
+function advtrains.save_keys(tbl, keys)
+ local new={}
+ for _,key in ipairs(keys) do
+ new[key] = tbl[key]
+ end
+ return new
+end
+
+function advtrains.get_real_index_position(path, index)
+ if not path or not index then return end
+
+ local first_pos=path[math.floor(index)]
+ local second_pos=path[math.floor(index)+1]
+
+ if not first_pos or not second_pos then return nil end
+
+ local factor=index-math.floor(index)
+ local actual_pos={x=first_pos.x-(first_pos.x-second_pos.x)*factor, y=first_pos.y-(first_pos.y-second_pos.y)*factor, z=first_pos.z-(first_pos.z-second_pos.z)*factor,}
+ return actual_pos
+end
+function advtrains.pos_median(pos1, pos2)
+ return {x=pos1.x-(pos1.x-pos2.x)*0.5, y=pos1.y-(pos1.y-pos2.y)*0.5, z=pos1.z-(pos1.z-pos2.z)*0.5}
+end
+function advtrains.abs_ceil(i)
+ return math.ceil(math.abs(i))*math.sign(i)
+end
+
+function advtrains.serialize_inventory(inv)
+ local ser={}
+ local liszts=inv:get_lists()
+ for lisztname, liszt in pairs(liszts) do
+ ser[lisztname]={}
+ for idx, item in ipairs(liszt) do
+ local istring=item:to_string()
+ if istring~="" then
+ ser[lisztname][idx]=istring
+ end
+ end
+ end
+ return minetest.serialize(ser)
+end
+function advtrains.deserialize_inventory(sers, inv)
+ local ser=minetest.deserialize(sers)
+ if ser then
+ inv:set_lists(ser)
+ return true
+ end
+ return false
+end
+
+--is_protected wrapper that checks for protection_bypass privilege
+function advtrains.is_protected(pos, name)
+ if not name then
+ error("advtrains.is_protected() called without name parameter!")
+ end
+ if minetest.check_player_privs(name, {protection_bypass=true}) then
+ --player can bypass protection
+ return false
+ end
+ return minetest.is_protected(pos, name)
+end
+
+function advtrains.is_creative(name)
+ if not name then
+ error("advtrains.is_creative() called without name parameter!")
+ end
+ if minetest.check_player_privs(name, {creative=true}) then
+ return true
+ end
+ return minetest.settings:get_bool("creative_mode")
+end
+
+function advtrains.ms_to_kmh(speed)
+ return speed * 3.6
+end
+
+-- 4 possible inputs:
+-- integer: just do that modulo calculation
+-- table with c set: rotate c
+-- table with tables: rotate each
+-- table with integers: rotate each (probably no use case)
+function advtrains.rotate_conn_by(conn, rotate)
+ if tonumber(conn) then
+ return (conn+rotate)%AT_CMAX
+ elseif conn.c then
+ return { c = (conn.c+rotate)%AT_CMAX, y = conn.y}
+ end
+ local tmp={}
+ for connid, data in ipairs(conn) do
+ tmp[connid]=advtrains.rotate_conn_by(data, rotate)
+ end
+ return tmp
+end
+
+
+function advtrains.oppd(dir)
+ return advtrains.rotate_conn_by(dir, AT_CMAX/2)
+end
+--conn_to_match like rotate_conn_by
+--other_conns have to be a table of conn tables!
+function advtrains.conn_matches_to(conn, other_conns)
+ if tonumber(conn) then
+ for connid, data in ipairs(other_conns) do
+ if advtrains.oppd(conn) == data.c then return connid end
+ end
+ return false
+ elseif conn.c then
+ for connid, data in ipairs(other_conns) do
+ local cmp = advtrains.oppd(conn)
+ if cmp.c == data.c and (cmp.y or 0) == (data.y or 0) then return connid end
+ end
+ return false
+ end
+ local tmp={}
+ for connid, data in ipairs(conn) do
+ local backmatch = advtrains.conn_matches_to(data, other_conns)
+ if backmatch then return backmatch, connid end --returns <connid of other rail> <connid of this rail>
+ end
+ return false
+end
+
+
+-- returns: <adjacent pos>, <conn index of adjacent>, <my conn index>, <railheight of adjacent>
+function advtrains.get_adjacent_rail(this_posnr, this_conns_p, conn_idx, drives_on)
+ local this_pos = advtrains.round_vector_floor_y(this_posnr)
+ local this_conns = this_conns_p
+ if not this_conns then
+ _, this_conns = advtrains.get_rail_info_at(this_pos)
+ end
+ if not conn_idx then
+ for coni, _ in ipairs(this_conns) do
+ local adj_pos, adj_conn_idx, _, nry, nco = advtrains.get_adjacent_rail(this_pos, this_conns, coni)
+ if adj_pos then return adj_pos,adj_conn_idx,coni,nry, nco end
+ end
+ return nil
+ end
+
+ local conn = this_conns[conn_idx]
+ local conn_y = conn.y or 0
+ local adj_pos = advtrains.dirCoordSet(this_pos, conn.c);
+
+ while conn_y>=1 do
+ conn_y = conn_y - 1
+ adj_pos.y = adj_pos.y + 1
+ end
+
+ local nextnode_ok, nextconns, nextrail_y=advtrains.get_rail_info_at(adj_pos, drives_on)
+ if not nextnode_ok then
+ adj_pos.y = adj_pos.y - 1
+ conn_y = conn_y + 1
+ nextnode_ok, nextconns, nextrail_y=advtrains.get_rail_info_at(adj_pos, drives_on)
+ if not nextnode_ok then
+ return nil
+ end
+ end
+ local adj_connid = advtrains.conn_matches_to({c=conn.c, y=conn_y}, nextconns)
+ if adj_connid then
+ return adj_pos, adj_connid, conn_idx, nextrail_y, nextconns
+ end
+ return nil
+end
+
+local connlku={[2]={2,1}, [3]={2,1,1}, [4]={2,1,4,3}}
+function advtrains.get_matching_conn(conn, nconns)
+ return connlku[nconns][conn]
+end
+
+function advtrains.random_id()
+ local idst=""
+ for i=0,5 do
+ idst=idst..(math.random(0,9))
+ end
+ return idst
+end
+-- Shorthand for pos_to_string and round_vector_floor_y
+function advtrains.roundfloorpts(pos)
+ return minetest.pos_to_string(advtrains.round_vector_floor_y(pos))
+end
+
+-- insert an element into a table if it does not yet exist there
+-- equalfunc is a function to compare equality, defaults to ==
+-- returns true if the element was inserted
+function advtrains.insert_once(tab, elem, equalfunc)
+ for _,e in pairs(tab) do
+ if equalfunc and equalfunc(elem, e) or e==elem then return false end
+ end
+ tab[#tab+1] = elem
+ return true
+end
+
+local hext = { [0]="0",[1]="1",[2]="2",[3]="3",[4]="4",[5]="5",[6]="6",[7]="7",[8]="8",[9]="9",[10]="A",[11]="B",[12]="C",[13]="D",[14]="E",[15]="F"}
+local dect = { ["0"]=0,["1"]=1,["2"]=2,["3"]=3,["4"]=4,["5"]=5,["6"]=6,["7"]=7,["8"]=8,["9"]=9,["A"]=10,["B"]=11,["C"]=12,["D"]=13,["E"]=14,["F"]=15}
+
+local f = atfloor
+
+local function hex(i)
+ local x=i+32768
+ local c4 = x % 16
+ x = f(x / 16)
+ local c3 = x % 16
+ x = f(x / 16)
+ local c2 = x % 16
+ x = f(x / 16)
+ local c1 = x % 16
+ return (hext[c1]) .. (hext[c2]) .. (hext[c3]) .. (hext[c4])
+end
+
+local function c(s,i) return dect[string.sub(s,i,i)] end
+
+local function dec(s)
+ return (c(s,1)*4096 + c(s,2)*256 + c(s,3)*16 + c(s,4))-32768
+end
+-- Takes a position vector and outputs a encoded value suitable as table index
+-- This is essentially a hexadecimal representation of the position (+32768)
+-- Order (YYY)YXXXXZZZZ
+function advtrains.encode_pos(pos)
+ return hex(pos.y) .. hex(pos.x) .. hex(pos.z)
+end
+
+-- decodes a position encoded with encode_pos
+function advtrains.decode_pos(pts)
+ local stry = string.sub(pts, 1,4)
+ local strx = string.sub(pts, 5,8)
+ local strz = string.sub(pts, 9,12)
+ return vector.new(dec(strx), dec(stry), dec(strz))
+end
+
+--[[ Benchmarking code
+local tdt = {}
+local tlt = {}
+local tet = {}
+
+for i=1,1000000 do
+ tdt[i] = vector.new(math.random(-65536, 65535), math.random(-65536, 65535), math.random(-65536, 65535))
+ if i%1000 == 0 then
+ tlt[#tlt+1] = tdt[i]
+ end
+end
+
+local t1=os.clock()
+for i=1,1000000 do
+ local pe = advtrains.encode_pos(tdt[i])
+ local pb = advtrains.decode_pos(pe)
+ tet[pe] = i
+end
+for i,v in ipairs(tlt) do
+ local lk = tet[advtrains.encode_pos(v)]
+end
+atdebug("endec",os.clock()-t1,"s")
+
+tet = {}
+
+t1=os.clock()
+for i=1,1000000 do
+ local pe = minetest.pos_to_string(tdt[i])
+ local pb = minetest.string_to_pos(pe)
+ tet[pe] = i
+end
+for i,v in ipairs(tlt) do
+ local lk = tet[minetest.pos_to_string(v)]
+end
+atdebug("pts",os.clock()-t1,"s")
+
+--Results:
+--2018-11-29 16:57:08: ACTION[Main]: [advtrains]endec 1.786451 s
+--2018-11-29 16:57:10: ACTION[Main]: [advtrains]pts 2.566377 s
+]]
+
+
diff --git a/main.lua b/main.lua
new file mode 100644
index 0000000..460c29d
--- /dev/null
+++ b/main.lua
@@ -0,0 +1,230 @@
+-- advtrains track map generator
+-- Usage:...
+
+-- Viewport maximum coordinate in all directions
+local maxc = 5000
+
+-- embed an image called "world.png"
+local wimg = false
+-- image file resolution (not world resolution!)
+local wimresx = 3000
+local wimresy = 3000
+-- one pixel is ... nodes
+local wimscale = 4
+
+
+
+--Constant for maximum connection value/division of the circle
+AT_CMAX = 16
+
+advtrains = {}
+minetest = {}
+core = minetest
+
+--table for track nodes/connections
+trackconns = {}
+
+-- math library seems to be missing this function
+math.hypot = function(a,b) return math.sqrt(a*a + b*b) end
+
+-- need to declare this for trackdefs
+function attrans(str) return str end
+
+-- pos to string
+local function pts(pos)
+ return pos.x .. "," .. pos.y .. "," .. pos.z
+end
+
+--Advtrains dump (special treatment of pos and sigd)
+function atdump(t, intend)
+ local str
+ if type(t)=="table" then
+ if t.x and t.y and t.z then
+ str=minetest.pos_to_string(t)
+ elseif t.p and t.s then -- interlocking sigd
+ str="S["..minetest.pos_to_string(t.p).."/"..t.s.."]"
+ else
+ str="{"
+ local intd = (intend or "") .. " "
+ for k,v in pairs(t) do
+ if type(k)~="string" or not string.match(k, "^path[_]?") then
+ -- do not print anything path-related
+ str = str .. "\n" .. intd .. atdump(k, intd) .. " = " ..atdump(v, intd)
+ end
+ end
+ str = str .. "\n" .. (intend or "") .. "}"
+ end
+ elseif type(t)=="boolean" then
+ if t then
+ str="true"
+ else
+ str="false"
+ end
+ elseif type(t)=="function" then
+ str="<function>"
+ elseif type(t)=="userdata" then
+ str="<userdata>"
+ else
+ str=""..t
+ end
+ return str
+end
+
+dofile("vector.lua")
+dofile("serialize.lua")
+dofile("helpers.lua")
+dofile("tracks.lua")
+dofile("track_defs.lua")
+
+dofile("nodedb.lua")
+
+
+-- Load saves
+local file, err = io.open("advtrains", "r")
+local tbl = minetest.deserialize(file:read("*a"))
+if type(tbl) ~= "table" then
+ error("not a table")
+end
+if tbl.version then
+
+ advtrains.ndb.load_data(tbl.ndb)
+
+else
+ error("Incompatible save format!")
+end
+file:close()
+
+-- open svg file
+
+local svgfile = io.open("out.svg", "w")
+
+svgfile:write([[
+<?xml version="1.0" standalone="no" ?>
+<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 20010904//EN"
+ "http://www.w3.org/TR/2001/REC-SVG-20010904/DTD/svg10.dtd">
+<svg width="1024" height="800" xmlns="http://www.w3.org/2000/svg"
+ xmlns:xlink="http://www.w3.org/1999/xlink" ]])
+
+
+svgfile:write('viewBox="'..(-maxc)..' '..(-maxc)..' '..(2*maxc)..' '..(2*maxc)..'" >')
+
+
+svgfile:write([[
+<circle cx="0" cy="0" r="2" stroke="red" stroke-width="1" />
+]])
+
+if wimg then
+ local wimx = -(wimresx*wimscale/2)
+ local wimy = -(wimresy*wimscale/2)
+ local wimw = wimresx*wimscale
+ local wimh = wimresy*wimscale
+
+ svgfile:write('<image xlink:href="world.png" x="'..wimx..'" y="'..wimy..'" height="'..wimh..'px" width="'..wimw..'px"/>')
+end
+
+local function writec(text)
+ print(text)
+ svgfile:write("<!-- " .. text .. " -->\n")
+end
+
+
+-- everything set up. Start generating an SVG
+-- All nodes that have been fit into a polyline are removed from the NDB, in order to not draw them again.
+
+-- "Restart points" for the breadth-first traverser (set when more than 2 conns present)
+-- {pos = <position>, connid = <int>, conn = <conndef>}
+-- Note that the node at "pos" is already deleted from the NDB at the time of recall, therefore "conn" is specified
+local bfs_rsp = {}
+
+
+-- Points of the current polyline. Inserted as xyz vectors, maybe we'll use the y value one day
+local current_polyline = {}
+
+-- Traverser function from interlocking, highly modified
+local function gen_rsp_polyline(rsp)
+
+ -- trick a bit
+ local pos, connid, conns = rsp.pos, 1, {rsp.conn}
+ current_polyline[#current_polyline+1] = pos
+
+ while true do
+ local adj_pos, adj_connid, conn_idx, nextrail_y, next_conns = advtrains.get_adjacent_rail(pos, conns, connid)
+ if not adj_pos then
+ return
+ end
+ -- continue traversing
+ local conn_mainbranch
+ for nconnid, nconn in ipairs(next_conns) do
+ if adj_connid ~= nconnid then
+ if not conn_mainbranch then
+ --use the first one found to continue
+ conn_mainbranch = nconnid
+ --writec(nconnid.." nconn mainbranch")
+ else
+ -- insert bfs reminders for other conns
+ table.insert(bfs_rsp, {pos = adj_pos, connid = nconnid, conn = nconn})
+ --writec(nconnid.." nconn bfs")
+ end
+ end
+ end
+
+ -- save in polyline and delete from ndb
+ --writec("Saved pos: "..pts(adj_pos).." mainbranch cont "..conn_mainbranch.." nextconns "..atdump(next_conns))
+ current_polyline[#current_polyline+1] = adj_pos
+ advtrains.ndb.clear(adj_pos)
+
+ pos, connid, conns = adj_pos, conn_mainbranch, next_conns
+
+ end
+end
+
+
+local function polyline_write(pl)
+ local str = {'<polyline style="fill:none;stroke:black;stroke-width:1" points="'}
+
+ local i
+ local e
+ local lastldir = {x=0, y=0}
+ for i=1,#pl do
+ e = pl[i]
+ -- Note that we mirror y, so positive z is up
+ table.insert(str, e.x .. "," .. -(e.z) .. " ")
+ end
+
+ table.insert(str, '" />\n')
+
+ svgfile:write(table.concat(str))
+end
+
+
+-- while there are entries in the nodedb
+-- 1. find a starting point
+ local stpos, conns = advtrains.ndb.mapper_find_starting_point()
+while stpos do
+
+ writec("Restart at position "..pts(stpos))
+ for connid, conn in ipairs(conns) do
+ table.insert(bfs_rsp, {pos = stpos, connid = connid, conn = conn})
+ end
+ advtrains.ndb.clear(stpos)
+
+ -- 2. while there are BFS entries
+ while #bfs_rsp > 0 do
+ -- make polylines
+ local current_rsp = bfs_rsp[#bfs_rsp]
+ bfs_rsp[#bfs_rsp] = nil
+ --print("Starting polyline at "..pts(current_rsp.pos).."/"..current_rsp.connid)
+
+
+ current_polyline = {}
+
+ gen_rsp_polyline(current_rsp)
+
+ polyline_write(current_polyline)
+ end
+ stpos, conns = advtrains.ndb.mapper_find_starting_point()
+end
+
+svgfile:write("</svg>")
+svgfile:close()
+
diff --git a/nodedb.lua b/nodedb.lua
new file mode 100644
index 0000000..f79dbbd
--- /dev/null
+++ b/nodedb.lua
@@ -0,0 +1,163 @@
+--nodedb.lua
+--database of all nodes that have 'save_in_at_nodedb' field set to true in node definition
+
+
+--serialization format:
+--(2byte z) (2byte y) (2byte x) (2byte contentid)
+--contentid := (14bit nodeid, 2bit param2)
+
+local function int_to_bytes(i)
+ local x=i+32768--clip to positive integers
+ local cH = math.floor(x / 256) % 256;
+ local cL = math.floor(x ) % 256;
+ return(string.char(cH, cL));
+end
+local function bytes_to_int(bytes)
+ local t={string.byte(bytes,1,-1)}
+ local n =
+ t[1] * 256 +
+ t[2]
+ return n-32768
+end
+local function l2b(x)
+ return x%4
+end
+local function u14b(x)
+ return math.floor(x/4)
+end
+local ndb={}
+
+--local variables for performance
+local ndb_nodeids={}
+local ndb_nodes={}
+
+local function ndbget(x,y,z)
+ local ny=ndb_nodes[y]
+ if ny then
+ local nx=ny[x]
+ if nx then
+ return nx[z]
+ end
+ end
+ return nil
+end
+local function ndbset(x,y,z,v)
+ if not ndb_nodes[y] then
+ ndb_nodes[y]={}
+ end
+ if not ndb_nodes[y][x] then
+ ndb_nodes[y][x]={}
+ end
+ ndb_nodes[y][x][z]=v
+end
+
+
+local path="advtrains_ndb2"
+--load
+--nodeids get loaded by advtrains init.lua and passed here
+function ndb.load_data(data)
+ ndb_nodeids = data and data.nodeids or {}
+ local file, err = io.open(path, "rb")
+ if not file then
+ print("Couldn't load the node database: ", err or "Unknown Error")
+ else
+ local cnt=0
+ local hst_z=file:read(2)
+ local hst_y=file:read(2)
+ local hst_x=file:read(2)
+ local cid=file:read(2)
+ while hst_z and hst_y and hst_x and cid and #hst_z==2 and #hst_y==2 and #hst_x==2 and #cid==2 do
+ ndbset(bytes_to_int(hst_x), bytes_to_int(hst_y), bytes_to_int(hst_z), bytes_to_int(cid))
+ cnt=cnt+1
+ hst_z=file:read(2)
+ hst_y=file:read(2)
+ hst_x=file:read(2)
+ cid=file:read(2)
+ end
+ print("nodedb: read", cnt, "nodes.")
+ file:close()
+ end
+end
+
+--function to get node. track database is not helpful here.
+function ndb.get_node_or_nil(pos)
+ -- FIX for bug found on linuxworks server:
+ -- a loaded node might get read before the LBM has updated its state, resulting in wrongly set signals and switches
+ -- -> Using the saved node prioritarily.
+ local node = ndb.get_node_raw(pos)
+ if node then
+ return node
+ else
+ -- no minetest here
+ return nil
+ end
+end
+function ndb.get_node(pos)
+ local n=ndb.get_node_or_nil(pos)
+ if not n then
+ return {name="ignore", param2=0}
+ end
+ return n
+end
+function ndb.get_node_raw(pos)
+ local cid=ndbget(pos.x, pos.y, pos.z)
+ if cid then
+ local nodeid = ndb_nodeids[u14b(cid)]
+ if nodeid then
+ return {name=nodeid, param2 = l2b(cid)}
+ end
+ end
+ return nil
+end
+
+function ndb.clear(pos)
+ ndbset(pos.x, pos.y, pos.z, nil)
+end
+
+
+--get_node with pseudoload. now we only need track data, so we can use the trackdb as second fallback
+--nothing new will be saved inside the trackdb.
+--returns:
+--true, conn1, conn2, rely1, rely2, railheight in case everything's right.
+--false if it's not a rail or the train does not drive on this rail, but it is loaded or
+--nil if the node is neither loaded nor in trackdb
+--the distraction between false and nil will be needed only in special cases.(train initpos)
+function advtrains.get_rail_info_at(pos)
+ local rdp=advtrains.round_vector_floor_y(pos)
+
+ local node=ndb.get_node_or_nil(rdp)
+ if not node then return end
+
+ local nodename=node.name
+
+ local conns, railheight, tracktype=advtrains.get_track_connections(node.name, node.param2)
+
+ if not conns then
+ return false
+ end
+
+ return true, conns, railheight
+end
+
+
+-- mapper-specific
+
+function ndb.mapper_find_starting_point()
+ for y, ty in pairs(ndb_nodes) do
+ for x, tx in pairs(ty) do
+ for z, v in pairs(tx) do
+ local pos = {x=x, y=y, z=z}
+ local node_ok, conns, _ = advtrains.get_rail_info_at(pos)
+ if node_ok then
+ return pos, conns
+ else
+ -- this is a signal or something similar, ignore.
+ tx[z]=nil
+ end
+ end
+ end
+ end
+end
+
+
+advtrains.ndb = ndb
diff --git a/serialize.lua b/serialize.lua
new file mode 100755
index 0000000..692ddd5
--- /dev/null
+++ b/serialize.lua
@@ -0,0 +1,221 @@
+--- Lua module to serialize values as Lua code.
+-- From: https://github.com/fab13n/metalua/blob/no-dll/src/lib/serialize.lua
+-- License: MIT
+-- @copyright 2006-2997 Fabien Fleutot <metalua@gmail.com>
+-- @author Fabien Fleutot <metalua@gmail.com>
+-- @author ShadowNinja <shadowninja@minetest.net>
+--------------------------------------------------------------------------------
+
+--- Serialize an object into a source code string. This string, when passed as
+-- an argument to deserialize(), returns an object structurally identical to
+-- the original one. The following are currently supported:
+-- * Booleans, numbers, strings, and nil.
+-- * Functions; uses interpreter-dependent (and sometimes platform-dependent) bytecode!
+-- * Tables; they can cantain multiple references and can be recursive, but metatables aren't saved.
+-- This works in two phases:
+-- 1. Recursively find and record multiple references and recursion.
+-- 2. Recursively dump the value into a string.
+-- @param x Value to serialize (nil is allowed).
+-- @return load()able string containing the value.
+function core.serialize(x)
+ local local_index = 1 -- Top index of the "_" local table in the dump
+ -- table->nil/1/2 set of tables seen.
+ -- nil = not seen, 1 = seen once, 2 = seen multiple times.
+ local seen = {}
+
+ -- nest_points are places where a table appears within itself, directly
+ -- or not. For instance, all of these chunks create nest points in
+ -- table x: "x = {}; x[x] = 1", "x = {}; x[1] = x",
+ -- "x = {}; x[1] = {y = {x}}".
+ -- To handle those, two tables are used by mark_nest_point:
+ -- * nested - Transient set of tables being currently traversed.
+ -- Used for detecting nested tables.
+ -- * nest_points - parent->{key=value, ...} table cantaining the nested
+ -- keys and values in the parent. They're all dumped after all the
+ -- other table operations have been performed.
+ --
+ -- mark_nest_point(p, k, v) fills nest_points with information required
+ -- to remember that key/value (k, v) creates a nest point in table
+ -- parent. It also marks "parent" and the nested item(s) as occuring
+ -- multiple times, since several references to it will be required in
+ -- order to patch the nest points.
+ local nest_points = {}
+ local nested = {}
+ local function mark_nest_point(parent, k, v)
+ local nk, nv = nested[k], nested[v]
+ local np = nest_points[parent]
+ if not np then
+ np = {}
+ nest_points[parent] = np
+ end
+ np[k] = v
+ seen[parent] = 2
+ if nk then seen[k] = 2 end
+ if nv then seen[v] = 2 end
+ end
+
+ -- First phase, list the tables and functions which appear more than
+ -- once in x.
+ local function mark_multiple_occurences(x)
+ local tp = type(x)
+ if tp ~= "table" and tp ~= "function" then
+ -- No identity (comparison is done by value, not by instance)
+ return
+ end
+ if seen[x] == 1 then
+ seen[x] = 2
+ elseif seen[x] ~= 2 then
+ seen[x] = 1
+ end
+
+ if tp == "table" then
+ nested[x] = true
+ for k, v in pairs(x) do
+ if nested[k] or nested[v] then
+ mark_nest_point(x, k, v)
+ else
+ mark_multiple_occurences(k)
+ mark_multiple_occurences(v)
+ end
+ end
+ nested[x] = nil
+ end
+ end
+
+ local dumped = {} -- object->varname set
+ local local_defs = {} -- Dumped local definitions as source code lines
+
+ -- Mutually recursive local functions:
+ local dump_val, dump_or_ref_val
+
+ -- If x occurs multiple times, dump the local variable rather than
+ -- the value. If it's the first time it's dumped, also dump the
+ -- content in local_defs.
+ function dump_or_ref_val(x)
+ if seen[x] ~= 2 then
+ return dump_val(x)
+ end
+ local var = dumped[x]
+ if var then -- Already referenced
+ return var
+ end
+ -- First occurence, create and register reference
+ local val = dump_val(x)
+ local i = local_index
+ local_index = local_index + 1
+ var = "_["..i.."]"
+ local_defs[#local_defs + 1] = var.." = "..val
+ dumped[x] = var
+ return var
+ end
+
+ -- Second phase. Dump the object; subparts occuring multiple times
+ -- are dumped in local variables which can be referenced multiple
+ -- times. Care is taken to dump local vars in a sensible order.
+ function dump_val(x)
+ local tp = type(x)
+ if x == nil then return "nil"
+ elseif tp == "string" then return string.format("%q", x)
+ elseif tp == "boolean" then return x and "true" or "false"
+ elseif tp == "function" then
+ return string.format("loadstring(%q)", string.dump(x))
+ elseif tp == "number" then
+ -- Serialize integers with string.format to prevent
+ -- scientific notation, which doesn't preserve
+ -- precision and breaks things like node position
+ -- hashes. Serialize floats normally.
+ if math.floor(x) == x then
+ return string.format("%d", x)
+ else
+ return tostring(x)
+ end
+ elseif tp == "table" then
+ local vals = {}
+ local idx_dumped = {}
+ local np = nest_points[x]
+ for i, v in ipairs(x) do
+ if not np or not np[i] then
+ vals[#vals + 1] = dump_or_ref_val(v)
+ end
+ idx_dumped[i] = true
+ end
+ for k, v in pairs(x) do
+ if (not np or not np[k]) and
+ not idx_dumped[k] then
+ vals[#vals + 1] = "["..dump_or_ref_val(k).."] = "
+ ..dump_or_ref_val(v)
+ end
+ end
+ return "{"..table.concat(vals, ", ").."}"
+ else
+ error("Can't serialize data of type "..tp)
+ end
+ end
+
+ local function dump_nest_points()
+ for parent, vals in pairs(nest_points) do
+ for k, v in pairs(vals) do
+ local_defs[#local_defs + 1] = dump_or_ref_val(parent)
+ .."["..dump_or_ref_val(k).."] = "
+ ..dump_or_ref_val(v)
+ end
+ end
+ end
+
+ mark_multiple_occurences(x)
+ local top_level = dump_or_ref_val(x)
+ dump_nest_points()
+
+ if next(local_defs) then
+ return "local _ = {}\n"
+ ..table.concat(local_defs, "\n")
+ .."\nreturn "..top_level
+ else
+ return "return "..top_level
+ end
+end
+
+-- Deserialization
+
+local env = {
+ loadstring = loadstring,
+}
+
+local safe_env = {
+ loadstring = function() end,
+}
+
+function core.deserialize(str, safe)
+ if type(str) ~= "string" then
+ return nil, "Cannot deserialize type '"..type(str)
+ .."'. Argument must be a string."
+ end
+ if str:byte(1) == 0x1B then
+ return nil, "Bytecode prohibited"
+ end
+ local f, err = loadstring(str)
+ if not f then return nil, err end
+ setfenv(f, safe and safe_env or env)
+
+ local good, data = pcall(f)
+ if good then
+ return data
+ else
+ return nil, data
+ end
+end
+
+
+-- Unit tests
+local test_in = {cat={sound="nyan", speed=400}, dog={sound="woof"}}
+local test_out = core.deserialize(core.serialize(test_in))
+
+assert(test_in.cat.sound == test_out.cat.sound)
+assert(test_in.cat.speed == test_out.cat.speed)
+assert(test_in.dog.sound == test_out.dog.sound)
+
+test_in = {escape_chars="\n\r\t\v\\\"\'", non_european="θשׁ٩∂"}
+test_out = core.deserialize(core.serialize(test_in))
+assert(test_in.escape_chars == test_out.escape_chars)
+assert(test_in.non_european == test_out.non_european)
+
diff --git a/track_defs.lua b/track_defs.lua
new file mode 100644
index 0000000..aac2ebf
--- /dev/null
+++ b/track_defs.lua
@@ -0,0 +1,152 @@
+--== Insert track defs here! ==--
+-- Default tracks for advtrains
+-- (c) orwell96 and contributors
+
+--flat
+advtrains.register_tracks("default", {
+ nodename_prefix="advtrains:dtrack",
+ texture_prefix="advtrains_dtrack",
+ models_prefix="advtrains_dtrack",
+ models_suffix=".b3d",
+ shared_texture="advtrains_dtrack_shared.png",
+ description=attrans("Track"),
+ formats={},
+}, advtrains.ap.t_30deg_flat)
+--slopes
+advtrains.register_tracks("default", {
+ nodename_prefix="advtrains:dtrack",
+ texture_prefix="advtrains_dtrack",
+ models_prefix="advtrains_dtrack",
+ models_suffix=".obj",
+ shared_texture="advtrains_dtrack_shared.png",
+ second_texture="default_gravel.png",
+ description=attrans("Track"),
+ formats={vst1={true, false, true}, vst2={true, false, true}, vst31={true}, vst32={true}, vst33={true}},
+}, advtrains.ap.t_30deg_slope)
+
+--bumpers
+advtrains.register_tracks("default", {
+ nodename_prefix="advtrains:dtrack_bumper",
+ texture_prefix="advtrains_dtrack_bumper",
+ models_prefix="advtrains_dtrack_bumper",
+ models_suffix=".b3d",
+ shared_texture="advtrains_dtrack_rail.png",
+ --bumpers still use the old texture until the models are redone.
+ description=attrans("Bumper"),
+ formats={},
+}, advtrains.ap.t_30deg_straightonly)
+
+
+
+-- atc track
+advtrains.register_tracks("default", {
+ nodename_prefix="advtrains:dtrack_atc",
+ texture_prefix="advtrains_dtrack_atc",
+ models_prefix="advtrains_dtrack",
+ models_suffix=".b3d",
+ shared_texture="advtrains_dtrack_shared_atc.png",
+ description=attrans("ATC controller"),
+ formats={},
+ get_additional_definiton = advtrains.atc_function
+}, advtrains.trackpresets.t_30deg_straightonly)
+
+advtrains.register_tracks("default", {
+ nodename_prefix="advtrains:dtrack_unload",
+ texture_prefix="advtrains_dtrack_unload",
+ models_prefix="advtrains_dtrack",
+ models_suffix=".b3d",
+ shared_texture="advtrains_dtrack_shared_unload.png",
+ description=attrans("Unloading Track"),
+ formats={},
+ get_additional_definiton = function(def, preset, suffix, rotation)
+ return {
+ after_dig_node=function(pos)
+ advtrains.invalidate_all_paths()
+ advtrains.ndb.clear(pos)
+ end,
+ advtrains = {
+ on_train_enter = function(pos, train_id)
+ train_load(pos, train_id, true)
+ end,
+ },
+ }
+ end
+ }, advtrains.trackpresets.t_30deg_straightonly)
+advtrains.register_tracks("default", {
+ nodename_prefix="advtrains:dtrack_load",
+ texture_prefix="advtrains_dtrack_load",
+ models_prefix="advtrains_dtrack",
+ models_suffix=".b3d",
+ shared_texture="advtrains_dtrack_shared_load.png",
+ description=attrans("Loading Track"),
+ formats={},
+ get_additional_definiton = function(def, preset, suffix, rotation)
+ return {
+ after_dig_node=function(pos)
+ advtrains.invalidate_all_paths()
+ advtrains.ndb.clear(pos)
+ end,
+
+ advtrains = {
+ on_train_enter = function(pos, train_id)
+ train_load(pos, train_id, false)
+ end,
+ },
+ }
+ end
+ }, advtrains.trackpresets.t_30deg_straightonly)
+
+
+ advtrains.register_tracks("default", {
+ nodename_prefix="advtrains:dtrack_detector_off",
+ texture_prefix="advtrains_dtrack_detector",
+ models_prefix="advtrains_dtrack",
+ models_suffix=".b3d",
+ shared_texture="advtrains_dtrack_shared_detector_off.png",
+ description=attrans("Detector Rail"),
+ formats={},
+ get_additional_definiton = function(def, preset, suffix, rotation)
+ return {
+ mesecons = {
+ receptor = {
+ state = mesecon.state.off,
+ rules = advtrains.meseconrules
+ }
+ },
+ advtrains = {
+ on_train_enter=function(pos, train_id)
+ advtrains.ndb.swap_node(pos, {name="advtrains:dtrack_detector_on".."_"..suffix..rotation, param2=advtrains.ndb.get_node(pos).param2})
+ mesecon.receptor_on(pos, advtrains.meseconrules)
+ end
+ }
+ }
+ end
+ }, advtrains.ap.t_30deg_straightonly)
+ advtrains.register_tracks("default", {
+ nodename_prefix="advtrains:dtrack_detector_on",
+ texture_prefix="advtrains_dtrack",
+ models_prefix="advtrains_dtrack",
+ models_suffix=".b3d",
+ shared_texture="advtrains_dtrack_shared_detector_on.png",
+ description="Detector(on)(you hacker you)",
+ formats={},
+ get_additional_definiton = function(def, preset, suffix, rotation)
+ return {
+ mesecons = {
+ receptor = {
+ state = mesecon.state.on,
+ rules = advtrains.meseconrules
+ }
+ },
+ advtrains = {
+ on_train_leave=function(pos, train_id)
+ advtrains.ndb.swap_node(pos, {name="advtrains:dtrack_detector_off".."_"..suffix..rotation, param2=advtrains.ndb.get_node(pos).param2})
+ mesecon.receptor_off(pos, advtrains.meseconrules)
+ end
+ }
+ }
+ end
+ }, advtrains.ap.t_30deg_straightonly_noplacer)
+
+
+--== END insert track defs ==--
diff --git a/tracks.lua b/tracks.lua
new file mode 100644
index 0000000..b04c585
--- /dev/null
+++ b/tracks.lua
@@ -0,0 +1,265 @@
+--advtrains by orwell96, see readme.txt
+
+--dev-time settings:
+--EDIT HERE
+--If the old non-model rails on straight tracks should be replaced by the new...
+--false: no
+--true: yes
+advtrains.register_replacement_lbms=false
+
+--[[TracksDefinition
+nodename_prefix
+texture_prefix
+description
+common={}
+straight={}
+straight45={}
+curve={}
+curve45={}
+lswitchst={}
+lswitchst45={}
+rswitchst={}
+rswitchst45={}
+lswitchcr={}
+lswitchcr45={}
+rswitchcr={}
+rswitchcr45={}
+vert1={
+ --you'll probably want to override mesh here
+}
+vert2={
+ --you'll probably want to override mesh here
+}
+]]--
+advtrains.all_tracktypes={}
+
+--definition preparation
+local function conns(c1, c2, r1, r2) return {{c=c1, y=r1}, {c=c2, y=r2}} end
+local function conns3(c1, c2, c3, r1, r2, r3) return {{c=c1, y=r1}, {c=c2, y=r2}, {c=c3, y=r3}} end
+
+advtrains.ap={}
+advtrains.ap.t_30deg_flat={
+ regstep=1,
+ variant={
+ st={
+ conns = conns(0,8),
+ desc = "straight",
+ tpdouble = true,
+ tpsingle = true,
+ trackworker = "cr",
+ },
+ cr={
+ conns = conns(0,7),
+ desc = "curve",
+ tpdouble = true,
+ trackworker = "swlst",
+ },
+ swlst={
+ conns = conns3(0,8,7),
+ desc = "left switch (straight)",
+ trackworker = "swrst",
+ switchalt = "swlcr",
+ switchmc = "on",
+ switchst = "st",
+ },
+ swlcr={
+ conns = conns3(0,7,8),
+ desc = "left switch (curve)",
+ trackworker = "swrcr",
+ switchalt = "swlst",
+ switchmc = "off",
+ switchst = "cr",
+ },
+ swrst={
+ conns = conns3(0,8,9),
+ desc = "right switch (straight)",
+ trackworker = "st",
+ switchalt = "swrcr",
+ switchmc = "on",
+ switchst = "st",
+ },
+ swrcr={
+ conns = conns3(0,9,8),
+ desc = "right switch (curve)",
+ trackworker = "st",
+ switchalt = "swrst",
+ switchmc = "off",
+ switchst = "cr",
+ },
+ },
+ regtp=true,
+ tpdefault="st",
+ trackworker={
+ ["swrcr"]="st",
+ ["swrst"]="st",
+ ["cr"]="swlst",
+ ["swlcr"]="swrcr",
+ ["swlst"]="swrst",
+ },
+ rotation={"", "_30", "_45", "_60"},
+}
+advtrains.ap.t_30deg_slope={
+ regstep=1,
+ variant={
+ vst1={conns = conns(8,0,0,0.5), rail_y = 0.25, desc = "steep uphill 1/2", slope=true},
+ vst2={conns = conns(8,0,0.5,1), rail_y = 0.75, desc = "steep uphill 2/2", slope=true},
+ vst31={conns = conns(8,0,0,0.33), rail_y = 0.16, desc = "uphill 1/3", slope=true},
+ vst32={conns = conns(8,0,0.33,0.66), rail_y = 0.5, desc = "uphill 2/3", slope=true},
+ vst33={conns = conns(8,0,0.66,1), rail_y = 0.83, desc = "uphill 3/3", slope=true},
+ },
+ regsp=true,
+ slopeplacer={
+ [2]={"vst1", "vst2"},
+ [3]={"vst31", "vst32", "vst33"},
+ max=3,--highest entry
+ },
+ slopeplacer_45={
+ [2]={"vst1_45", "vst2_45"},
+ max=2,
+ },
+ rotation={"", "_30", "_45", "_60"},
+ trackworker={},
+ increativeinv={},
+}
+advtrains.ap.t_30deg_straightonly={
+ regstep=1,
+ variant={
+ st={
+ conns = conns(0,8),
+ desc = "straight",
+ tpdouble = true,
+ tpsingle = true,
+ trackworker = "st",
+ },
+ },
+ regtp=true,
+ tpdefault="st",
+ rotation={"", "_30", "_45", "_60"},
+}
+advtrains.ap.t_30deg_straightonly_noplacer={
+ regstep=1,
+ variant={
+ st={
+ conns = conns(0,8),
+ desc = "straight",
+ tpdouble = true,
+ tpsingle = true,
+ trackworker = "st",
+ },
+ },
+ tpdefault="st",
+ rotation={"", "_30", "_45", "_60"},
+}
+advtrains.ap.t_45deg={
+ regstep=2,
+ variant={
+ st={
+ conns = conns(0,8),
+ desc = "straight",
+ tpdouble = true,
+ tpsingle = true,
+ trackworker = "cr",
+ },
+ cr={
+ conns = conns(0,6),
+ desc = "curve",
+ tpdouble = true,
+ trackworker = "swlst",
+ },
+ swlst={
+ conns = conns3(0,8,6),
+ desc = "left switch (straight)",
+ trackworker = "swrst",
+ switchalt = "swlcr",
+ switchmc = "on",
+ switchst = "st",
+ },
+ swlcr={
+ conns = conns3(0,6,8),
+ desc = "left switch (curve)",
+ trackworker = "swrcr",
+ switchalt = "swlst",
+ switchmc = "off",
+ switchst = "cr",
+ },
+ swrst={
+ conns = conns3(0,8,10),
+ desc = "right switch (straight)",
+ trackworker = "st",
+ switchalt = "swrcr",
+ switchmc = "on",
+ switchst = "st",
+ },
+ swrcr={
+ conns = conns3(0,10,8),
+ desc = "right switch (curve)",
+ trackworker = "st",
+ switchalt = "swrst",
+ switchmc = "off",
+ switchst = "cr",
+ },
+ },
+ regtp=true,
+ tpdefault="st",
+ trackworker={
+ ["swrcr"]="st",
+ ["swrst"]="st",
+ ["cr"]="swlst",
+ ["swlcr"]="swrcr",
+ ["swlst"]="swrst",
+ },
+ rotation={"", "_30", "_45", "_60"},
+}
+advtrains.trackpresets = advtrains.ap
+
+--definition format: ([] optional)
+--[[{
+ nodename_prefix
+ texture_prefix
+ [shared_texture]
+ models_prefix
+ models_suffix (with dot)
+ [shared_model]
+ formats={
+ st,cr,swlst,swlcr,swrst,swrcr,vst1,vst2
+ (each a table with indices 0-3, for if to register a rail with this 'rotation' table entry. nil is assumed as 'all', set {} to not register at all)
+ }
+ common={} change something on common rail appearance
+}
+[18.12.17] Note on new connection system:
+In order to support real rail crossing nodes and finally make the trackplacer respect switches, I changed the connection system.
+There can be a variable number of connections available. These are specified as tuples {c=<connection>, y=<rely>}
+The table "at_conns" consists of {<conn1>, <conn2>...}
+the "at_rail_y" property holds the value that was previously called "railheight"
+Depending on the number of connections:
+2 conns: regular rail
+3 conns: switch:
+ - when train passes in at conn1, will move out of conn2
+ - when train passes in at conn2 or conn3, will move out of conn1
+4 conns: cross (or cross switch, depending on arrangement of conns):
+ - conn1 <> conn2
+ - conn3 <> conn4
+]]
+
+function advtrains.register_tracks(tracktype, def, preset)
+ for suffix, var in pairs(preset.variant) do
+ for rotid, rotation in ipairs(preset.rotation) do
+ if not def.formats[suffix] or def.formats[suffix][rotid] then
+
+ --connections
+ local at_conns = advtrains.rotate_conn_by(var.conns, (rotid-1)*preset.regstep)
+
+ trackconns[def.nodename_prefix.."_"..suffix..rotation] = at_conns
+
+ end
+ end
+ end
+end
+
+
+function advtrains.get_track_connections(name, param2)
+
+ if not trackconns[name] then return end
+
+ return advtrains.rotate_conn_by(trackconns[name], param2*AT_CMAX/4), nil, nil
+end
diff --git a/vector.lua b/vector.lua
new file mode 100755
index 0000000..0549f9a
--- /dev/null
+++ b/vector.lua
@@ -0,0 +1,145 @@
+
+vector = {}
+
+function vector.new(a, b, c)
+ if type(a) == "table" then
+ assert(a.x and a.y and a.z, "Invalid vector passed to vector.new()")
+ return {x=a.x, y=a.y, z=a.z}
+ elseif a then
+ assert(b and c, "Invalid arguments for vector.new()")
+ return {x=a, y=b, z=c}
+ end
+ return {x=0, y=0, z=0}
+end
+
+function vector.equals(a, b)
+ return a.x == b.x and
+ a.y == b.y and
+ a.z == b.z
+end
+
+function vector.length(v)
+ return math.hypot(v.x, math.hypot(v.y, v.z))
+end
+
+function vector.normalize(v)
+ local len = vector.length(v)
+ if len == 0 then
+ return {x=0, y=0, z=0}
+ else
+ return vector.divide(v, len)
+ end
+end
+
+function vector.floor(v)
+ return {
+ x = math.floor(v.x),
+ y = math.floor(v.y),
+ z = math.floor(v.z)
+ }
+end
+
+function vector.round(v)
+ return {
+ x = math.floor(v.x + 0.5),
+ y = math.floor(v.y + 0.5),
+ z = math.floor(v.z + 0.5)
+ }
+end
+
+function vector.apply(v, func)
+ return {
+ x = func(v.x),
+ y = func(v.y),
+ z = func(v.z)
+ }
+end
+
+function vector.distance(a, b)
+ local x = a.x - b.x
+ local y = a.y - b.y
+ local z = a.z - b.z
+ return math.hypot(x, math.hypot(y, z))
+end
+
+function vector.direction(pos1, pos2)
+ local x_raw = pos2.x - pos1.x
+ local y_raw = pos2.y - pos1.y
+ local z_raw = pos2.z - pos1.z
+ local x_abs = math.abs(x_raw)
+ local y_abs = math.abs(y_raw)
+ local z_abs = math.abs(z_raw)
+ if x_abs >= y_abs and
+ x_abs >= z_abs then
+ y_raw = y_raw * (1 / x_abs)
+ z_raw = z_raw * (1 / x_abs)
+ x_raw = x_raw / x_abs
+ end
+ if y_abs >= x_abs and
+ y_abs >= z_abs then
+ x_raw = x_raw * (1 / y_abs)
+ z_raw = z_raw * (1 / y_abs)
+ y_raw = y_raw / y_abs
+ end
+ if z_abs >= y_abs and
+ z_abs >= x_abs then
+ x_raw = x_raw * (1 / z_abs)
+ y_raw = y_raw * (1 / z_abs)
+ z_raw = z_raw / z_abs
+ end
+ return {x=x_raw, y=y_raw, z=z_raw}
+end
+
+
+function vector.add(a, b)
+ if type(b) == "table" then
+ return {x = a.x + b.x,
+ y = a.y + b.y,
+ z = a.z + b.z}
+ else
+ return {x = a.x + b,
+ y = a.y + b,
+ z = a.z + b}
+ end
+end
+
+function vector.subtract(a, b)
+ if type(b) == "table" then
+ return {x = a.x - b.x,
+ y = a.y - b.y,
+ z = a.z - b.z}
+ else
+ return {x = a.x - b,
+ y = a.y - b,
+ z = a.z - b}
+ end
+end
+
+function vector.multiply(a, b)
+ if type(b) == "table" then
+ return {x = a.x * b.x,
+ y = a.y * b.y,
+ z = a.z * b.z}
+ else
+ return {x = a.x * b,
+ y = a.y * b,
+ z = a.z * b}
+ end
+end
+
+function vector.divide(a, b)
+ if type(b) == "table" then
+ return {x = a.x / b.x,
+ y = a.y / b.y,
+ z = a.z / b.z}
+ else
+ return {x = a.x / b,
+ y = a.y / b,
+ z = a.z / b}
+ end
+end
+
+function vector.sort(a, b)
+ return {x = math.min(a.x, b.x), y = math.min(a.y, b.y), z = math.min(a.z, b.z)},
+ {x = math.max(a.x, b.x), y = math.max(a.y, b.y), z = math.max(a.z, b.z)}
+end