Fork of git@bananach.space:advtrains_netmapper.git
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

370 lines
10 KiB

--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}
-- Hex functions changed for 8bit
function advtrains.hex(i)
local x=math.floor(i)
local c2 = x % 16
x = math.floor(x / 16)
local c1 = x % 16
return (hext[c1]) .. (hext[c2])
end
local function c(s,i) return dect[string.sub(s,i,i)] end
function advtrains.dec(s)
return (c(s,1)*16 + c(s,2))
end