Remove zip release files, move mod to root, exclude assets from Makefile (#92)

1 files changed, 1005 insertions, 0 deletions

diff --git a/advtrains/trainlogic.lua b/advtrains/trainlogic.lua
new file mode 100644
index 0000000..483ea52
--- /dev/null
+++ b/advtrains/trainlogic.lua
@@ -0,0 +1,1005 @@
+--trainlogic.lua
+--controls train entities stuff about connecting/disconnecting/colliding trains and other things
+
+
+local benchmark=false
+local bm={}
+local bmlt=0
+local bmsteps=0
+local bmstepint=200
+atprintbm=function(action, ta)
+	if not benchmark then return end
+	local t=(os.clock()-ta)*1000
+	if not bm[action] then
+		bm[action]=t
+	else
+		bm[action]=bm[action]+t
+	end
+	bmlt=bmlt+t
+end
+function endstep()
+	if not benchmark then return end
+	bmsteps=bmsteps-1
+	if bmsteps<=0 then
+		bmsteps=bmstepint
+		for key, value in pairs(bm) do
+			minetest.chat_send_all(key.." "..(value/bmstepint).." ms avg.")
+		end
+		minetest.chat_send_all("Total time consumed by all advtrains actions per step: "..(bmlt/bmstepint).." ms avg.")
+		bm={}
+		bmlt=0
+	end
+end
+
+advtrains.train_accel_force=2--per second and divided by number of wagons
+advtrains.train_brake_force=3--per second, not divided by number of wagons
+advtrains.train_roll_force=0.5--per second, not divided by number of wagons, acceleration when rolling without brake
+advtrains.train_emerg_force=10--for emergency brakes(when going off track)
+
+
+advtrains.mainloop_trainlogic=function(dtime)
+	--build a table of all players indexed by pts. used by damage and door system.
+	advtrains.playersbypts={}
+	for _, player in pairs(minetest.get_connected_players()) do
+		if not advtrains.player_to_train_mapping[player:get_player_name()] then
+			--players in train are not subject to damage
+			local ptspos=minetest.pos_to_string(vector.round(player:getpos()))
+			advtrains.playersbypts[ptspos]=player
+		end
+	end
+	--regular train step
+	-- do in two steps: 
+	--  a: predict path and add all nodes to the advtrains.detector.on_node table
+	--  b: check for collisions based on these data
+	--  (and more)
+	local t=os.clock()
+	advtrains.detector.on_node={}
+	for k,v in pairs(advtrains.trains) do
+		advtrains.atprint_context_tid=sid(k)
+		advtrains.atprint_context_tid_full=k
+		advtrains.train_step_a(k, v, dtime)
+	end
+	for k,v in pairs(advtrains.trains) do
+		advtrains.atprint_context_tid=sid(k)
+		advtrains.atprint_context_tid_full=k
+		advtrains.train_step_b(k, v, dtime)
+	end
+	
+	advtrains.atprint_context_tid=nil
+	advtrains.atprint_context_tid_full=nil
+	
+	atprintbm("trainsteps", t)
+	endstep()
+end
+
+minetest.register_on_joinplayer(function(player)
+	return advtrains.pcall(function()
+		local pname=player:get_player_name()
+		local id=advtrains.player_to_train_mapping[pname]
+		if id then
+			local train=advtrains.trains[id]
+			if not train then advtrains.player_to_train_mapping[pname]=nil return end
+			--set the player to the train position.
+			--minetest will emerge the area and load the objects, which then will call reattach_all().
+			--because player is in mapping, it will not be subject to dying.
+			player:setpos(train.last_pos_prev)
+			--independent of this, cause all wagons of the train which are loaded to reattach their players
+			--needed because already loaded wagons won't call reattach_all()
+			for _,wagon in pairs(minetest.luaentities) do
+				if wagon.is_wagon and wagon.initialized and wagon.train_id==id then
+					wagon:reattach_all()
+				end
+			end
+		end
+	end)
+end)
+
+minetest.register_on_dieplayer(function(player)
+	return advtrains.pcall(function()
+		local pname=player:get_player_name()
+		local id=advtrains.player_to_train_mapping[pname]
+		if id then
+			local train=advtrains.trains[id]
+			if not train then advtrains.player_to_train_mapping[pname]=nil return end
+			for _,wagon in pairs(minetest.luaentities) do
+				if wagon.is_wagon and wagon.initialized and wagon.train_id==id then
+					--when player dies, detach him from the train
+					--call get_off_plr on every wagon since we don't know which one he's on.
+					wagon:get_off_plr(pname)
+				end
+			end
+		end
+	end)
+end)
+--[[
+train step structure:
+
+
+- legacy stuff
+- preparing the initial path and creating index
+- setting node coverage old indices
+- handle velocity influences:
+	- off-track
+	- atc
+	- player controls
+	- environment collision
+- update index = move
+- create path
+- update node coverage
+- do less important stuff such as checking trainpartload or removing
+
+-- break --
+- handle train collisions
+
+]]
+
+function advtrains.train_step_a(id, train, dtime)
+	--atprint("--- runcnt ",advtrains.mainloop_runcnt,": index",train.index,"end_index", train.end_index,"| max_iot", train.max_index_on_track, "min_iot", train.min_index_on_track, "<> pe_min", train.path_extent_min,"pe_max", train.path_extent_max)
+	if train.min_index_on_track then
+		assert(math.floor(train.min_index_on_track)==train.min_index_on_track)
+	end
+	--- 1. LEGACY STUFF ---
+	if not train.drives_on or not train.max_speed then
+		advtrains.update_trainpart_properties(id)
+	end
+	--TODO check for all vars to be present
+	if not train.velocity then
+		train.velocity=0
+	end
+	if not train.movedir or (train.movedir~=1 and train.movedir~=-1) then
+		train.movedir=1
+	end
+	--- 2. prepare initial path and index if needed ---
+	if not train.index then train.index=0 end
+	if not train.path then
+		if not train.last_pos then
+			--no chance to recover
+			atprint("train hasn't saved last-pos, removing train.")
+			advtrains.trains[id]=nil
+			return false
+		end
+		
+		local node_ok=advtrains.get_rail_info_at(advtrains.round_vector_floor_y(train.last_pos), train.drives_on)
+		
+		if node_ok==nil then
+			--block not loaded, do nothing
+			atprint("last_pos", advtrains.round_vector_floor_y(train.last_pos), "not loaded and not in ndb, waiting")
+			return nil
+		elseif node_ok==false then
+			atprint("no track here, (fail) removing train.")
+			advtrains.trains[id]=nil
+			return false
+		end
+		
+		if not train.last_pos_prev then
+			--no chance to recover
+			atprint("train hasn't saved last-pos_prev, removing train.")
+			advtrains.trains[id]=nil
+			return false
+		end
+		
+		local prevnode_ok=advtrains.get_rail_info_at(advtrains.round_vector_floor_y(train.last_pos_prev), train.drives_on)
+		
+		if prevnode_ok==nil then
+			--block not loaded, do nothing
+			atprint("last_pos_prev", advtrains.round_vector_floor_y(train.last_pos_prev), "not loaded and not in ndb, waiting")
+			return nil
+		elseif prevnode_ok==false then
+			atprint("no track at prev, (fail) removing train.")
+			advtrains.trains[id]=nil
+			return false
+		end
+		
+		train.index=(train.restore_add_index or 0)+(train.savedpos_off_track_index_offset or 0)
+		--restore_add_index is set by save() to prevent trains hopping to next round index. should be between -0.5 and 0.5
+		--savedpos_off_track_index_offset is set if train went off track. see below.
+		train.path={}
+		train.path_dist={}
+		train.path[0]=train.last_pos
+		train.path[-1]=train.last_pos_prev
+		train.path_dist[-1]=vector.distance(train.last_pos, train.last_pos_prev)
+		train.path_extent_min=-1
+		train.path_extent_max=0
+		train.min_index_on_track=-1
+		train.max_index_on_track=0
+		
+		--[[
+		Bugfix for trains randomly ignoring ATC rails:
+		- Paths have been invalidated. 1 gets executed and ensures an initial path
+		- 2a sets train end index. The problem is that path_dist is not known for the whole path, so train end index will be nearly trainlen
+		- Since the detector indices are also unknown, they get set to the new (wrong) train_end_index. Enter_node calls are not executed for the nodes that lie in between real end_index and trainlen.
+		- The next step, mistake is recognized, train leaves some positions. From there, everything works again.
+		To overcome this, we will generate the full required path here so that path_dist is available for get_train_end_index(). 
+		]]
+		advtrains.pathpredict(id, train)
+	end
+	
+	--- 2a. set train.end_index which is required in different places, IF IT IS NOT SET YET by STMT afterwards. ---
+	---   table entry to avoid triple recalculation ---
+	if not train.end_index then
+		train.end_index=advtrains.get_train_end_index(train)
+	end
+	
+	--- 2b. set node coverage old indices ---
+	
+	train.detector_old_index = math.floor(train.index)
+	train.detector_old_end_index = math.floor(train.end_index)
+	
+	--- 3. handle velocity influences ---
+	local train_moves=(train.velocity~=0)
+	
+	if train.recently_collided_with_env then
+		train.tarvelocity=0
+		if not train_moves then
+			train.recently_collided_with_env=false--reset status when stopped
+		end
+	end
+	if train.locomotives_in_train==0 then
+		train.tarvelocity=0
+	end
+	
+	--- 3a. this can be useful for debugs/warnings and is used for check_trainpartload ---
+	local t_info, train_pos=sid(id), train.path[math.floor(train.index)]
+	if train_pos then
+		t_info=t_info.." @"..minetest.pos_to_string(train_pos)
+		--atprint("train_pos:",train_pos)
+	end
+	
+	--apply off-track handling:
+	local front_off_track=train.max_index_on_track and train.index>train.max_index_on_track
+	local back_off_track=train.min_index_on_track and train.end_index<train.min_index_on_track
+	local pprint
+	
+	if front_off_track and back_off_track then--allow movement in both directions
+		if train.tarvelocity>1 then
+			train.tarvelocity=1
+			atwarn("Train",t_info,"is off track at both ends. Clipping velocity to 1")
+			pprint=true
+		end
+	elseif front_off_track then--allow movement only backward
+		if train.movedir==1 and train.tarvelocity>0 then
+			train.tarvelocity=0
+			atwarn("Train",t_info,"is off track. Trying to drive further out. Velocity clipped to 0")
+			pprint=true
+		end
+		if train.movedir==-1 and train.tarvelocity>1 then
+			train.tarvelocity=1
+			atwarn("Train",t_info,"is off track. Velocity clipped to 1")
+			pprint=true
+		end
+	elseif back_off_track then--allow movement only forward
+		if train.movedir==-1 and train.tarvelocity>0 then
+			train.tarvelocity=0
+			atwarn("Train",t_info,"is off track. Trying to drive further out. Velocity clipped to 0")
+			pprint=true
+		end
+		if train.movedir==1 and train.tarvelocity>1 then
+			train.tarvelocity=1
+			atwarn("Train",t_info,"is off track. Velocity clipped to 1")
+			pprint=true
+		end
+	end
+	if pprint then
+		atprint("max_iot", train.max_index_on_track, "min_iot", train.min_index_on_track, "<> index", train.index, "end_index", train.end_index)
+	end
+	
+	--interpret ATC command
+	if train.atc_brake_target and train.atc_brake_target>=train.velocity then
+		train.atc_brake_target=nil
+	end
+	if train.atc_wait_finish then
+		if not train.atc_brake_target and train.velocity==train.tarvelocity then
+			train.atc_wait_finish=nil
+		end
+	end
+	if train.atc_command then
+		if train.atc_delay<=0 and not train.atc_wait_finish then
+			advtrains.atc.execute_atc_command(id, train)
+		else
+			train.atc_delay=train.atc_delay-dtime
+		end
+	end
+	
+	--make brake adjust the tarvelocity if necessary
+	if train.brake and (math.ceil(train.velocity)-1)<train.tarvelocity then
+		train.tarvelocity=math.max((math.ceil(train.velocity)-1), 0)
+	end
+	
+	--- 3a. actually calculate new velocity ---
+	if train.velocity~=train.tarvelocity then
+		local applydiff=0
+		local mass=#train.trainparts
+		local diff=train.tarvelocity-train.velocity
+		if diff>0 then--accelerating, force will be brought on only by locomotives.
+			--atprint("accelerating with default force")
+			applydiff=(math.min((advtrains.train_accel_force*train.locomotives_in_train*dtime)/mass, math.abs(diff)))
+		else--decelerating
+			if front_off_track or back_off_track or train.recently_collided_with_env then --every wagon has a brake, so not divided by mass.
+				--atprint("braking with emergency force")
+				applydiff= -(math.min((advtrains.train_emerg_force*dtime), math.abs(diff)))
+			elseif train.brake or (train.atc_brake_target and train.atc_brake_target<train.velocity) then
+				--atprint("braking with default force")
+				--no math.min, because it can grow beyond tarvelocity, see up there
+				--dont worry, it will never fall below zero.
+				applydiff= -((advtrains.train_brake_force*dtime))
+			else
+				--atprint("roll")
+				applydiff= -(math.min((advtrains.train_roll_force*dtime), math.abs(diff)))
+			end
+		end
+		train.last_accel=(applydiff*train.movedir)
+		train.velocity=math.min(math.max( train.velocity+applydiff , 0), train.max_speed or 10)
+	else
+		train.last_accel=0
+	end
+	
+	--- 4. move train ---
+	
+	train.index=train.index and train.index+(((train.velocity*train.movedir)/(train.path_dist[math.floor(train.index)] or 1))*dtime) or 0
+	
+	--- 4a. update train.end_index to the new position ---
+	train.end_index=advtrains.get_train_end_index(train)
+	
+	--- 5. extend path as necessary ---
+	--why this is an extra function, see under 3.
+	advtrains.pathpredict(id, train, true)
+	
+	--- 5a. make pos/yaw available for possible recover calls ---
+	if train.max_index_on_track<train.index then --whoops, train went too far. the saved position will be the last one that lies on a track, and savedpos_off_track_index_offset will hold how far to go from here
+		train.savedpos_off_track_index_offset=train.index-train.max_index_on_track
+		train.last_pos=train.path[train.max_index_on_track]
+		train.last_pos_prev=train.path[train.max_index_on_track-1]
+		atprint("train is off-track (front), last positions kept at", train.last_pos, "/", train.last_pos_prev)
+	elseif train.min_index_on_track+1>train.index then --whoops, train went even more far. same behavior
+		train.savedpos_off_track_index_offset=train.index-train.min_index_on_track
+		train.last_pos=train.path[train.min_index_on_track+1]
+		train.last_pos_prev=train.path[train.min_index_on_track]
+		atprint("train is off-track (back), last positions kept at", train.last_pos, "/", train.last_pos_prev)
+	else --regular case
+		train.savedpos_off_track_index_offset=nil
+		train.last_pos=train.path[math.floor(train.index+0.5)]
+		train.last_pos_prev=train.path[math.floor(train.index-0.5)]
+	end
+	
+	--- 5b. Remove path items that are no longer used ---
+	-- Necessary since path items are no longer invalidated in save steps
+	local path_pregen_keep=20
+	local offtrack_keep=4
+	local gen_front_keep= path_pregen_keep
+	local gen_back_keep= math.floor(- train.trainlen - path_pregen_keep)
+	
+	local delete_min=math.min(train.max_index_on_track - offtrack_keep, math.floor(train.index)+gen_back_keep)
+	local delete_max=math.max(train.min_index_on_track + offtrack_keep, math.floor(train.index)+gen_front_keep)
+	
+	if train.path_extent_min<delete_min then
+		atprint(sid(id),"clearing path min ",train.path_extent_min," to ",delete_min)
+		for i=train.path_extent_min,delete_min-1 do
+			train.path[i]=nil
+			train.path_dist[i]=nil
+		end
+		train.path_extent_min=delete_min
+		train.min_index_on_track=math.max(train.min_index_on_track, delete_min)
+	end
+	if train.path_extent_max>delete_max then
+		atprint(sid(id),"clearing path max ",train.path_extent_max," to ",delete_max)
+		train.path_dist[delete_max]=nil
+		for i=delete_max+1,train.path_extent_max do
+			train.path[i]=nil
+			train.path_dist[i]=nil
+		end
+		train.path_extent_max=delete_max
+		train.max_index_on_track=math.min(train.max_index_on_track, delete_max)
+	end
+	
+	--- 6. update node coverage ---
+	
+	-- when paths get cleared, the old indices set above will be up-to-date and represent the state in which the last run of this code was made
+	local ifo, ifn, ibo, ibn = train.detector_old_index, math.floor(train.index), train.detector_old_end_index, math.floor(train.end_index)
+	
+	local path=train.path
+	
+	if train.enter_node_all then
+		--field set by create_new_train_at.
+		--ensures that new train calls enter_node on all nodes
+		for i=ibn, ifn do
+			if path[i] then
+				advtrains.detector.enter_node(path[i], id)
+			end
+		end
+		train.enter_node_all=nil
+	else
+		for i=ibn, ifn do
+			if path[i] then
+				local pts=minetest.pos_to_string(path[i])
+				if not (advtrains.detector.on_node[pts] and advtrains.detector.on_node[pts]~=id) then
+					advtrains.detector.stay_node(path[i], id)
+				end
+			end
+		end
+		
+		if ifn>ifo then
+			for i=ifo+1, ifn do
+				if path[i] then
+					local pts=minetest.pos_to_string(path[i])
+					if advtrains.detector.on_node[pts] and advtrains.detector.on_node[pts]~=id then
+						--if another train has signed up for this position first, it won't be recognized in train_step_b. So do collision here.
+						atprint("Collision detected in enter_node callbacks (front) @",pts,"with",sid(advtrains.detector.on_node[pts]))
+						advtrains.collide_and_spawn_couple(id, path[i], advtrains.detector.on_node[pts], false)
+					end
+					atprint("enter_node (front) @index",i,"@",pts,"on_node",sid(advtrains.detector.on_node[pts]))
+					advtrains.detector.enter_node(path[i], id)
+				end
+			end
+		elseif ifn<ifo then
+			for i=ifn+1, ifo do
+				if path[i] then
+					advtrains.detector.leave_node(path[i], id)
+				end
+			end
+		end
+		if ibn<ibo then
+			for i=ibn, ibo-1 do
+				if path[i] then
+					local pts=minetest.pos_to_string(path[i])
+					if advtrains.detector.on_node[pts] and advtrains.detector.on_node[pts]~=id then
+						--if another train has signed up for this position first, it won't be recognized in train_step_b. So do collision here.
+						atprint("Collision detected in enter_node callbacks (back) @",pts,"on_node",sid(advtrains.detector.on_node[pts]))
+						advtrains.collide_and_spawn_couple(id, path[i], advtrains.detector.on_node[pts], true)
+					end
+					atprint("enter_node (back) @index",i,"@",pts,"with",sid(advtrains.detector.on_node[pts]))
+					advtrains.detector.enter_node(path[i], id)
+				end
+			end
+		elseif ibn>ibo then
+			for i=ibo, ibn-1 do
+				if path[i] then
+					advtrains.detector.leave_node(path[i], id)
+				end
+			end
+		end
+	end
+	
+	--- 7. do less important stuff ---
+	--check for any trainpart entities if they have been unloaded. do this only if train is near a player, to not spawn entities into unloaded areas
+	
+	train.check_trainpartload=(train.check_trainpartload or 0)-dtime
+	local node_range=(math.max((minetest.settings:get("active_block_range") or 0),1)*16)
+	if train.check_trainpartload<=0 then
+		local ori_pos=train_pos --see 3a.
+		--atprint("[train "..id.."] at "..minetest.pos_to_string(vector.round(ori_pos)))
+		
+		local should_check=false
+		for _,p in ipairs(minetest.get_connected_players()) do
+			should_check=should_check or ((vector.distance(ori_pos, p:getpos())<node_range))
+		end
+		if should_check then
+			advtrains.update_trainpart_properties(id)
+		end
+		train.check_trainpartload=2
+	end
+	--remove?
+	if #train.trainparts==0 then
+		atprint("[train "..sid(id).."] has empty trainparts, removing.")
+		advtrains.detector.leave_node(path[train.detector_old_index], id)
+		advtrains.trains[id]=nil
+		return
+	end
+end
+
+--about regular: Used by 1. to ensure path gets generated far enough, since end index is not known at this time.
+function advtrains.pathpredict(id, train, regular)
+	--TODO duplicate code under 5b.
+	local path_pregen=10
+	
+	local gen_front= path_pregen
+	local gen_back= - train.trainlen - path_pregen
+	if regular then
+		gen_front=math.max(train.index, train.detector_old_index) + path_pregen
+		gen_back=math.min(train.end_index, train.detector_old_end_index) - path_pregen
+	end
+	
+	local maxn=train.path_extent_max or 0
+	while maxn < gen_front do--pregenerate
+		local conway
+		if train.max_index_on_track == maxn then
+			atprint("maxn conway for ",maxn,train.path[maxn],maxn-1,train.path[maxn-1])
+			conway=advtrains.conway(train.path[maxn], train.path[maxn-1], train.drives_on)
+		end
+		if conway then
+			train.path[maxn+1]=conway
+			train.max_index_on_track=maxn+1
+		else
+			--do as if nothing has happened and preceed with path
+			--but do not update max_index_on_track
+			atprint("over-generating path max to index ",(maxn+1)," (position ",train.path[maxn]," )")
+			train.path[maxn+1]=vector.add(train.path[maxn], vector.subtract(train.path[maxn], train.path[maxn-1]))
+		end
+		train.path_dist[maxn]=vector.distance(train.path[maxn+1], train.path[maxn])
+		maxn=maxn+1
+	end
+	train.path_extent_max=maxn
+	
+	local minn=train.path_extent_min or -1
+	while minn > gen_back do
+		local conway
+		if train.min_index_on_track == minn then
+			atprint("minn conway for ",minn,train.path[minn],minn+1,train.path[minn+1])
+			conway=advtrains.conway(train.path[minn], train.path[minn+1], train.drives_on)
+		end
+		if conway then
+			train.path[minn-1]=conway
+			train.min_index_on_track=minn-1
+		else
+			--do as if nothing has happened and preceed with path
+			--but do not update min_index_on_track
+			atprint("over-generating path min to index ",(minn-1)," (position ",train.path[minn]," )")
+			train.path[minn-1]=vector.add(train.path[minn], vector.subtract(train.path[minn], train.path[minn+1]))
+		end
+		train.path_dist[minn-1]=vector.distance(train.path[minn], train.path[minn-1])
+		minn=minn-1
+	end
+	train.path_extent_min=minn
+	if not train.min_index_on_track then train.min_index_on_track=-1 end
+	if not train.max_index_on_track then train.max_index_on_track=0 end
+end
+
+
+function advtrains.train_step_b(id, train, dtime)
+
+	--hacky fix: if train_step_a returned in phase 2, end_index may not be set.
+	--just return
+	if not train.end_index then
+		return
+	end
+
+	--- 8. check for collisions with other trains and damage players ---
+	
+	local train_moves=(train.velocity~=0)
+	
+	if train_moves then
+		local collpos
+		local coll_grace=1
+		if train.movedir==1 then
+			collpos=advtrains.get_real_index_position(train.path, train.index-coll_grace)
+		else
+			collpos=advtrains.get_real_index_position(train.path, train.end_index+coll_grace)
+		end
+		if collpos then
+			local rcollpos=advtrains.round_vector_floor_y(collpos)
+			for x=-1,1 do
+				for z=-1,1 do
+					local testpos=vector.add(rcollpos, {x=x, y=0, z=z})
+					--- 8a Check collision ---
+					local testpts=minetest.pos_to_string(testpos)
+					if advtrains.detector.on_node[testpts] and advtrains.detector.on_node[testpts]~=id then
+						--collides
+						advtrains.collide_and_spawn_couple(id, testpos, advtrains.detector.on_node[testpts], train.movedir==-1)
+					end
+					--- 8b damage players ---
+					if not minetest.settings:get_bool("creative_mode") then
+						local player=advtrains.playersbypts[testpts]
+						if player and train.velocity>3 then
+							--instantly kill player
+							--drop inventory contents first, to not to spawn bones
+							local player_inv=player:get_inventory()
+							for i=1,player_inv:get_size("main") do
+								minetest.add_item(testpos, player_inv:get_stack("main", i))
+							end
+							for i=1,player_inv:get_size("craft") do
+								minetest.add_item(testpos, player_inv:get_stack("craft", i))
+							end
+							-- empty lists main and craft
+							player_inv:set_list("main", {})
+							player_inv:set_list("craft", {})
+							player:set_hp(0)
+						end
+					end
+				end
+			end
+		end
+	end
+end
+
+--returns new id
+function advtrains.create_new_train_at(pos, pos_prev)
+	local newtrain_id=os.time()..os.clock()
+	while advtrains.trains[newtrain_id] do newtrain_id=os.time()..os.clock() end--ensure uniqueness(will be unneccessary)
+	
+	advtrains.trains[newtrain_id]={}
+	advtrains.trains[newtrain_id].last_pos=pos
+	advtrains.trains[newtrain_id].last_pos_prev=pos_prev
+	advtrains.trains[newtrain_id].tarvelocity=0
+	advtrains.trains[newtrain_id].velocity=0
+	advtrains.trains[newtrain_id].trainparts={}
+	
+	advtrains.trains[newtrain_id].enter_node_all=true
+	
+	return newtrain_id
+end
+
+
+function advtrains.get_train_end_index(train)
+	return advtrains.get_real_path_index(train, train.trainlen or 2)--this function can be found inside wagons.lua since it's more related to wagons. we just set trainlen as pos_in_train
+end
+
+function advtrains.add_wagon_to_train(wagon, train_id, index)
+	local train=advtrains.trains[train_id]
+	if index then
+		table.insert(train.trainparts, index, wagon.unique_id)
+	else
+		table.insert(train.trainparts, wagon.unique_id)
+	end
+	--this is not the usual case!!!
+	--we may set initialized because the wagon has no chance to step()
+	wagon.initialized=true
+	--TODO is this art or can we throw it away?
+	advtrains.update_trainpart_properties(train_id)
+end
+function advtrains.update_trainpart_properties(train_id, invert_flipstate)
+	local train=advtrains.trains[train_id]
+	train.drives_on=advtrains.all_tracktypes
+	train.max_speed=20
+	local rel_pos=0
+	local count_l=0
+	for i, w_id in ipairs(train.trainparts) do
+		local wagon=nil
+		for aoid,iwagon in pairs(minetest.luaentities) do
+			if iwagon.is_wagon and iwagon.unique_id==w_id then
+				if wagon then
+					--duplicate
+					atprint("update_trainpart_properties: Removing duplicate wagon with id="..aoid)
+					iwagon.object:remove()
+				else
+					wagon=iwagon
+				end
+			end
+		end
+		if not wagon then
+			if advtrains.wagon_save[w_id] then
+				--spawn a new and initialize it with the properties from wagon_save
+				wagon=minetest.add_entity(train.last_pos, advtrains.wagon_save[w_id].entity_name):get_luaentity()
+				if not wagon then
+					minetest.chat_send_all("[advtrains] Warning: Wagon "..advtrains.wagon_save[w_id].entity_name.." does not exist. Make sure all required modules are loaded!")
+				else
+					wagon:init_from_wagon_save(w_id)
+				end
+			end
+		end
+		if wagon then
+			rel_pos=rel_pos+wagon.wagon_span
+			wagon.train_id=train_id
+			wagon.pos_in_train=rel_pos
+			wagon.pos_in_trainparts=i
+			wagon.old_velocity_vector=nil
+			if wagon.is_locomotive then
+				count_l=count_l+1
+			end
+			if invert_flipstate then
+				wagon.wagon_flipped = not wagon.wagon_flipped
+			end
+			rel_pos=rel_pos+wagon.wagon_span
+			
+			if wagon.drives_on then
+				for k,_ in pairs(train.drives_on) do
+					if not wagon.drives_on[k] then
+						train.drives_on[k]=nil
+					end
+				end
+			end
+			train.max_speed=math.min(train.max_speed, wagon.max_speed)
+			if i==1 then
+				train.couple_lock_front=wagon.lock_couples
+			end
+			if i==#train.trainparts then
+				train.couple_lock_back=wagon.lock_couples
+			end
+			
+		else
+			atprint(w_id.." not loaded and no save available")
+			--what the hell...
+			table.remove(train.trainparts, pit)
+		end
+	end
+	train.trainlen=rel_pos
+	train.locomotives_in_train=count_l
+end
+
+function advtrains.split_train_at_wagon(wagon)
+	--get train
+	local train=advtrains.trains[wagon.train_id]
+	if not train.path then return end
+	
+	local real_pos_in_train=advtrains.get_real_path_index(train, wagon.pos_in_train)
+	local pos_for_new_train=train.path[math.floor(real_pos_in_train+wagon.wagon_span)]
+	local pos_for_new_train_prev=train.path[math.floor(real_pos_in_train-1+wagon.wagon_span)]
+	
+	--before doing anything, check if both are rails. else do not allow
+	if not pos_for_new_train then
+		atprint("split_train: pos_for_new_train not set")
+		return false
+	end
+	local node_ok=advtrains.get_rail_info_at(advtrains.round_vector_floor_y(pos_for_new_train), train.drives_on)
+	if not node_ok then
+		atprint("split_train: pos_for_new_train ",advtrains.round_vector_floor_y(pos_for_new_train_prev)," not loaded or is not a rail")
+		return false
+	end
+	
+	if not train.last_pos_prev then
+		atprint("split_train: pos_for_new_train_prev not set")
+		return false
+	end
+	
+	local prevnode_ok=advtrains.get_rail_info_at(advtrains.round_vector_floor_y(pos_for_new_train), train.drives_on)
+	if not prevnode_ok then
+		atprint("split_train: pos_for_new_train_prev ", advtrains.round_vector_floor_y(pos_for_new_train_prev), " not loaded or is not a rail")
+		return false
+	end
+	
+	--create subtrain
+	local newtrain_id=advtrains.create_new_train_at(pos_for_new_train, pos_for_new_train_prev)
+	local newtrain=advtrains.trains[newtrain_id]
+	--insert all wagons to new train
+	for k,v in ipairs(train.trainparts) do
+		if k>=wagon.pos_in_trainparts then
+			table.insert(newtrain.trainparts, v)
+			train.trainparts[k]=nil
+		end
+	end
+	--update train parts
+	advtrains.update_trainpart_properties(wagon.train_id)--atm it still is the desierd id.
+	advtrains.update_trainpart_properties(newtrain_id)
+	train.tarvelocity=0
+	newtrain.velocity=train.velocity
+	newtrain.tarvelocity=0
+	newtrain.enter_node_all=true
+end
+
+--there are 4 cases:
+--1/2. F<->R F<->R regular, put second train behind first
+--->frontpos of first train will match backpos of second
+--3.   F<->R R<->F flip one of these trains, take the other as new train
+--->backpos's will match
+--4.   R<->F F<->R flip one of these trains and take it as new parent
+--->frontpos's will match
+
+--true when trains are facing each other. needed on colliding.
+-- check done by iterating paths and checking their direction
+--returns nil when not on the same track at all OR when required path items are not generated. this distinction may not always be needed.
+function advtrains.trains_facing(train1, train2)
+	local sr_pos=train1.path[math.floor(train1.index)]
+	local sr_pos_p=train1.path[math.floor(train1.index)-1]
+
+	for i=advtrains.minN(train2.path), advtrains.maxN(train2.path) do
+		if vector.equals(sr_pos, train2.path[i]) then
+			if train2.path[i+1] and vector.equals(sr_pos_p, train2.path[i+1]) then return true end
+			if train2.path[i-1] and vector.equals(sr_pos_p, train2.path[i-1]) then return false end
+			return nil
+		end
+	end
+	return nil
+end
+
+function advtrains.collide_and_spawn_couple(id1, pos, id2, t1_is_backpos)
+	if minetest.settings:get_bool("advtrains_disable_collisions") then
+		return
+	end
+	
+	atprint("COLLISION: "..sid(id1).." and "..sid(id2).." at ",pos,", t1_is_backpos="..(t1_is_backpos and "true" or "false"))
+	--TODO:
+	local train1=advtrains.trains[id1]
+	
+	-- do collision
+	train1.recently_collided_with_env=true
+	train1.velocity=0.5*train1.velocity
+	train1.movedir=train1.movedir*-1
+	train1.tarvelocity=0
+	
+	local train2=advtrains.trains[id2]
+	
+	if not train1 or not train2 then return end
+	
+	local found
+	for i=advtrains.minN(train1.path), advtrains.maxN(train1.path) do
+		if vector.equals(train1.path[i], pos) then
+			found=true
+		end
+	end
+	if not found then
+		atprint("Err: pos not in path. Not spawning a couple")
+		return 
+	end
+	
+	local frontpos2=train2.path[math.floor(train2.detector_old_index)]
+	local backpos2=train2.path[math.floor(train2.detector_old_end_index)]
+	local t2_is_backpos
+	atprint("End positions: ",frontpos2,backpos2)
+	
+	t2_is_backpos = vector.distance(backpos2, pos) < vector.distance(frontpos2, pos)
+	
+	atprint("t2_is_backpos="..(t2_is_backpos and "true" or "false"))
+	
+	local t1_has_couple
+	if t1_is_backpos then
+		t1_has_couple=train1.couple_eid_back
+	else
+		t1_has_couple=train1.couple_eid_front
+	end
+	local t2_has_couple
+	if t2_is_backpos then
+		t2_has_couple=train2.couple_eid_back
+	else
+		t2_has_couple=train2.couple_eid_front
+	end
+	
+	if t1_has_couple then
+		if minetest.object_refs[t1_has_couple] then minetest.object_refs[t1_has_couple]:remove() end
+	end
+	if t2_has_couple then
+		if minetest.object_refs[t2_has_couple] then minetest.object_refs[t2_has_couple]:remove() end
+	end
+	local obj=minetest.add_entity(pos, "advtrains:couple")
+	if not obj then atprint("failed creating object") return end
+	local le=obj:get_luaentity()
+	le.train_id_1=id1
+	le.train_id_2=id2
+	le.train1_is_backpos=t1_is_backpos
+	le.train2_is_backpos=t2_is_backpos
+	--find in object_refs
+	local p_aoi
+	for aoi, compare in pairs(minetest.object_refs) do
+		if compare==obj then
+			if t1_is_backpos then
+				train1.couple_eid_back=aoi
+			else
+				train1.couple_eid_front=aoi
+			end
+			if t2_is_backpos then
+				train2.couple_eid_back=aoi
+			else
+				train2.couple_eid_front=aoi
+			end
+			p_aoi=aoi
+		end
+	end
+	atprint("Couple spawned (ActiveObjectID ",p_aoi,")")
+end
+--order of trains may be irrelevant in some cases. check opposite cases. TODO does this work?
+--pos1 and pos2 are just needed to form a median.
+
+
+function advtrains.do_connect_trains(first_id, second_id, player)
+	local first, second=advtrains.trains[first_id], advtrains.trains[second_id]
+	
+	if not first or not second or not first.index or not second.index or not first.end_index or not second.end_index then
+		return false
+	end
+	
+	if first.couple_lock_back or second.couple_lock_front then
+		-- trains are ordered correctly!
+		if player then
+			minetest.chat_send_player(player:get_player_name(), "Can't couple: couples locked!")
+		end
+		return
+	end
+	
+	local first_wagoncnt=#first.trainparts
+	local second_wagoncnt=#second.trainparts
+	
+	for _,v in ipairs(second.trainparts) do
+		table.insert(first.trainparts, v)
+	end
+	--kick it like physics (with mass being #wagons)
+	local new_velocity=((first.velocity*first_wagoncnt)+(second.velocity*second_wagoncnt))/(first_wagoncnt+second_wagoncnt)
+	advtrains.trains[second_id]=nil
+	advtrains.update_trainpart_properties(first_id)
+	advtrains.trains[first_id].velocity=new_velocity
+	advtrains.trains[first_id].tarvelocity=0
+	return true
+end
+
+function advtrains.invert_train(train_id)
+	local train=advtrains.trains[train_id]
+	
+	local old_path=train.path
+	local old_path_dist=train.path_dist
+	train.path={}
+	train.path_dist={}
+	train.index, train.end_index= -train.end_index, -train.index
+	train.path_extent_min, train.path_extent_max = -train.path_extent_max, -train.path_extent_min
+	train.min_index_on_track, train.max_index_on_track = -train.max_index_on_track, -train.min_index_on_track
+	train.detector_old_index, train.detector_old_end_index = -train.detector_old_end_index, -train.detector_old_index
+	
+	train.velocity=-train.velocity
+	train.tarvelocity=-train.tarvelocity
+	for k,v in pairs(old_path) do
+		train.path[-k]=v
+		train.path_dist[-k-1]=old_path_dist[k]
+	end
+	local old_trainparts=train.trainparts
+	train.trainparts={}
+	for k,v in ipairs(old_trainparts) do
+		table.insert(train.trainparts, 1, v)--notice insertion at first place
+	end
+	advtrains.update_trainpart_properties(train_id, true)
+end
+
+function advtrains.get_train_at_pos(pos)
+	local ph=minetest.pos_to_string(advtrains.round_vector_floor_y(pos))
+	return advtrains.detector.on_node[ph]
+end
+
+function advtrains.invalidate_all_paths(pos)
+	--if a position is given, only invalidate inside a radius to save performance
+	local inv_radius=50
+	atprint("invalidating all paths")
+	for k,v in pairs(advtrains.trains) do
+		local exec=true
+		if pos and v.path and v.index and v.end_index then
+			--start and end pos of the train
+			local cmp1=v.path[math.floor(v.index)]
+			local cmp2=v.path[math.floor(v.end_index)]
+			if vector.distance(pos, cmp1)>inv_radius and vector.distance(pos, cmp2)>inv_radius then
+				exec=false
+			end
+		end
+		if exec then
+			--TODO duplicate code in init.lua avt_save()!
+			if v.index then
+				v.restore_add_index=v.index-math.floor(v.index+0.5)
+			end
+			v.path=nil
+			v.path_dist=nil
+			v.index=nil
+			v.end_index=nil
+			v.min_index_on_track=nil
+			v.max_index_on_track=nil
+			v.path_extent_min=nil
+			v.path_extent_max=nil
+			
+			v.detector_old_index=nil
+			v.detector_old_end_index=nil
+		end
+	end
+end
+
+--not blocking trains group
+function advtrains.train_collides(node)
+	if node and minetest.registered_nodes[node.name] and minetest.registered_nodes[node.name].walkable then
+		if not minetest.registered_nodes[node.name].groups.not_blocking_trains then
+			return true
+		end
+	end
+	return false
+end
+
+local nonblocknodes={
+	"default:fence_wood",
+	"default:fence_acacia_wood",
+	"default:fence_aspen_wood",
+	"default:fence_pine_wood",
+	"default:fence_junglewood",
+	"default:torch",
+	
+	"default:sign_wall",
+	"signs:sign_wall",
+	"signs:sign_wall_blue",
+	"signs:sign_wall_brown",
+	"signs:sign_wall_orange",
+	"signs:sign_wall_green",
+	"signs:sign_yard",
+	"signs:sign_wall_white_black",
+	"signs:sign_wall_red",
+	"signs:sign_wall_white_red",
+	"signs:sign_wall_yellow",
+	"signs:sign_post",
+	"signs:sign_hanging",
+	
+	
+}
+minetest.after(0, function()
+	for _,name in ipairs(nonblocknodes) do
+		if minetest.registered_nodes[name] then
+			minetest.registered_nodes[name].groups.not_blocking_trains=1
+		end
+	end
+end)