From ad82b9cd4e12e16a176a2af08d480fa939076515 Mon Sep 17 00:00:00 2001
From: orwell <orwell@bleipb.de>
Date: Sun, 15 Oct 2023 15:06:20 +0200
Subject: Forget it, and use the old preset tables for track registration. Just
 adapt it to the new definition.

---
 advtrains/init.lua             |   1 +
 advtrains/track_reg_helper.lua | 743 +++++++++++++++++++++++++++++++++++++++++
 advtrains/trackplacer.lua      |  36 +-
 advtrains/tracks.lua           |  24 +-
 4 files changed, 781 insertions(+), 23 deletions(-)
 create mode 100644 advtrains/track_reg_helper.lua

(limited to 'advtrains')

diff --git a/advtrains/init.lua b/advtrains/init.lua
index 2213937..78126e5 100644
--- a/advtrains/init.lua
+++ b/advtrains/init.lua
@@ -206,6 +206,7 @@ dofile(advtrains.modpath.."/trainhud.lua")
 dofile(advtrains.modpath.."/trackplacer.lua")
 dofile(advtrains.modpath.."/copytool.lua")
 dofile(advtrains.modpath.."/tracks.lua")
+dofile(advtrains.modpath.."/track_reg_helper.lua")
 dofile(advtrains.modpath.."/occupation.lua")
 dofile(advtrains.modpath.."/atc.lua")
 dofile(advtrains.modpath.."/wagons.lua")
diff --git a/advtrains/track_reg_helper.lua b/advtrains/track_reg_helper.lua
new file mode 100644
index 0000000..ad73a40
--- /dev/null
+++ b/advtrains/track_reg_helper.lua
@@ -0,0 +1,743 @@
+-- New track registration helper
+-- Retains the old table-template-based definition format, but adapts it to the new (advtrains 2.5)
+-- track definition system
+-- Note to future: This is actually just a work-saver, avoiding me to port over all the crossing nodes as well as the linetrack tracks.
+-- Future track mods should please directly use the appropriate advtrains.register_node_4rot() API and not rely on this!
+
+--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={
+	v25_format = true,
+	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 = "cr",
+			switchmc = "on",
+			switchst = "st",
+			switchprefix = "swl",
+			conn_map = {2,1,1},
+			stmref = "swl",
+		},
+		swlcr={
+			conns = conns3(0,8,7),
+			desc = "left switch (curve)",
+			trackworker = "swrcr",
+			switchalt = "st",
+			switchmc = "off",
+			switchst = "cr",
+			switchprefix = "swl",
+			conn_map = {3,1,1},
+			stmref = "swl",
+		},
+		swrst={
+			conns = conns3(0,8,9),
+			desc = "right switch (straight)",
+			trackworker = "st",
+			switchalt = "cr",
+			switchmc = "on",
+			switchst = "st",
+			switchprefix = "swr",
+			conn_map = {2,1,1},
+			stmref = "swr",
+		},
+		swrcr={
+			conns = conns3(0,8,9),
+			desc = "right switch (curve)",
+			trackworker = "st",
+			switchalt = "st",
+			switchmc = "off",
+			switchst = "cr",
+			switchprefix = "swr",
+			conn_map = {3,1,1},
+			stmref = "swr",
+		},
+	},
+	regtp=true,
+	tpdefault="st",
+	trackworker={
+		["swrcr"]="st",
+		["swrst"]="st",
+		["cr"]="swlst",
+		["swlcr"]="swrcr",
+		["swlst"]="swrst",
+	},
+	rotation={"", "_30", "_45", "_60"},
+	statemaps = {
+		swl = { st = "swlst", cr = "swlcr"},
+		swr = { st = "swrst", cr = "swrcr"}
+	}
+}
+advtrains.ap.t_yturnout={
+	v25_format = true,
+	regstep=1,
+	variant={
+		l={
+			conns = conns3(0,7,9),
+			desc = "Y-turnout (left)",
+			switchalt = "r",
+			switchmc = "off",
+			switchst = "l",
+			switchprefix = "",
+			conn_map = {2,1,1},
+			stmref = "sw",
+			tpsingle = true,
+		},
+		r={
+			conns = conns3(0,7,9),
+			desc = "Y-turnout (right)",
+			switchalt = "l",
+			switchmc = "on",
+			switchst = "r",
+			switchprefix = "",
+			conn_map = {3,1,1},
+			stmref = "sw",
+		}
+	},
+	regtp=true,
+	tpdefault="l",
+	rotation={"", "_30", "_45", "_60"},
+	statemaps = {
+		sw = { l = "l", r = "r"}
+	}
+}
+advtrains.ap.t_s3way={
+	v25_format = true,
+	regstep=1,
+	variant={
+		l={
+			conns = { {c=0}, {c=7}, {c=8}, {c=9}},
+			desc = "3-way turnout (left)",
+			switchalt = "s",
+			switchst="l",
+			switchprefix = "",
+			conn_map = {2,1,1},
+			stmref = "sw",
+		},
+		s={
+			conns = { {c=0}, {c=7}, {c=8}, {c=9}},
+			desc = "3-way turnout (straight)",
+			switchalt ="r",
+			switchst = "s",
+			switchprefix = "",
+			conn_map = {3,1,1},
+			stmref = "sw",
+			tpsingle = true,
+		},
+		r={
+			conns = { {c=0}, {c=7}, {c=8}, {c=9}},
+			desc = "3-way turnout (right)",
+			switchalt = "l",
+			switchst="r",
+			switchprefix = "",
+			conn_map = {4,1,1},
+			stmref = "sw",
+		}
+	},
+	regtp=true,
+	tpdefault="l",
+	rotation={"", "_30", "_45", "_60"},
+	statemaps = {
+		sw = { l = "l", s = "s", r = "r"}
+	}
+}
+advtrains.ap.t_30deg_slope={
+	v25_format = true,
+	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={
+	v25_format = true,
+	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={
+	v25_format = true,
+	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={
+	v25_format = true,
+	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 = "cr",
+			switchmc = "on",
+			switchst = "st",
+		},
+		swlcr={
+			conns = conns3(0,6,8),
+			desc = "left switch (curve)",
+			trackworker = "swrcr",
+			switchalt = "st",
+			switchmc = "off",
+			switchst = "cr",
+		},
+		swrst={
+			conns = conns3(0,8,10),
+			desc = "right switch (straight)",
+			trackworker = "st",
+			switchalt = "cr",
+			switchmc = "on",
+			switchst = "st",
+		},
+		swrcr={
+			conns = conns3(0,10,8),
+			desc = "right switch (curve)",
+			trackworker = "st",
+			switchalt = "st",
+			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_perpcrossing={
+	v25_format = true,
+	regstep = 1,
+	variant={
+		st={
+			conns = { {c=0}, {c=8}, {c=4}, {c=12} },
+			desc = "perpendicular crossing",
+			tpdouble = true,
+			tpsingle = true,
+			trackworker = "st",
+			conn_map = {2,1,4,3},
+		},
+	},
+	regtp=true,
+	tpdefault="st",
+	rotation={"", "_30", "_45", "_60"},
+}
+advtrains.ap.t_90plusx_crossing={
+	v25_format = true,
+	regstep = 1,
+	variant={
+		["30l"]={
+			conns = { {c=0}, {c=8}, {c=1}, {c=9} },
+			desc = "30/90 degree crossing (left)",
+			tpdouble = true,
+			tpsingle = true,
+			trackworker = "45l",
+			conn_map = {2,1,4,3},
+		},
+		["45l"]={
+			conns = { {c=0}, {c=8}, {c=2}, {c=10} },
+			desc = "45/90 degree crossing (left)",
+			tpdouble = true,
+			tpsingle = true,
+			trackworker = "60l",
+			conn_map = {2,1,4,3},
+		},
+		["60l"]={
+			conns = { {c=0}, {c=8}, {c=3}, {c=11}},
+			desc = "60/90 degree crossing (left)",
+			tpdouble = true,
+			tpsingle = true,
+			trackworker = "60r",
+			conn_map = {2,1,4,3},
+		},
+		["60r"]={
+			conns = { {c=0}, {c=8}, {c=5}, {c=13} },
+			desc = "60/90 degree crossing (right)",
+			tpdouble = true,
+			tpsingle = true,
+			trackworker = "45r",
+			conn_map = {2,1,4,3},
+		},
+		["45r"]={
+			conns = { {c=0}, {c=8}, {c=6}, {c=14} },
+			desc = "45/90 degree crossing (right)",
+			tpdouble = true,
+			tpsingle = true,
+			trackworker = "30r",
+			conn_map = {2,1,4,3},
+		},
+		["30r"]={
+			conns = { {c=0}, {c=8}, {c=7}, {c=15}},
+			desc = "30/90 degree crossing (right)",
+			tpdouble = true,
+			tpsingle = true,
+			trackworker = "30l",
+			conn_map = {2,1,4,3},
+		},
+	},
+	regtp=true,
+	tpdefault="30l",
+	rotation={""},
+	trackworker = {
+		["30l"] = "45l",
+		["45l"] = "60l",
+		["60l"] = "60r",
+		["60r"] = "45r",
+		["45r"] = "30r",
+		["30r"] = "30l",
+	}
+}
+
+advtrains.ap.t_diagonalcrossing = {
+	v25_format = true,
+	regstep=1,
+	variant={
+		["30l45r"]={
+			conns = {{c=1}, {c=9}, {c=6}, {c=14}},
+			desc = "30left-45right diagonal crossing",
+			tpdouble=true,
+			tpsingle=true,
+			trackworker="60l30l",
+			conn_map = {2,1,4,3},
+		},
+		["60l30l"]={
+			conns = {{c=3}, {c=11}, {c=1}, {c=9}},
+			desc = "30left-60right diagonal crossing",
+			tpdouble=true,
+			tpsingle=true,
+			trackworker="60l45r",
+			conn_map = {2,1,4,3},
+		},
+		["60l45r"]={
+			conns = {{c=3}, {c=11}, {c=6}, {c=14}},
+			desc = "60left-45right diagonal crossing",
+			tpdouble=true,
+			tpsingle=true,
+			trackworker="60l60r",
+			conn_map = {2,1,4,3},
+		},
+		["60l60r"]={
+			conns = {{c=3}, {c=11}, {c=5}, {c=13}},
+			desc = "60left-60right diagonal crossing",
+			tpdouble=true,
+			tpsingle=true,
+			trackworker="60r45l",
+			conn_map = {2,1,4,3},
+		},
+		--If 60l60r had a mirror image, it would be here, but it's symmetric.
+		-- 60l60r is also equivalent to 30l30r but rotated 90 degrees.
+		["60r45l"]={
+			conns = {{c=5}, {c=13}, {c=2}, {c=10}},
+			desc = "60right-45left diagonal crossing",
+			tpdouble=true,
+			tpsingle=true,
+			trackworker="60r30r",
+			conn_map = {2,1,4,3},
+		},
+		["60r30r"]={
+			conns = {{c=5}, {c=13}, {c=7}, {c=15}},
+			desc = "60right-30right diagonal crossing",
+			tpdouble=true,
+			tpsingle=true,
+			trackworker="30r45l",
+			conn_map = {2,1,4,3},
+		},
+		["30r45l"]={
+			conns = {{c=7}, {c=15}, {c=2}, {c=10}},
+			desc = "30right-45left diagonal crossing",
+			tpdouble=true,
+			tpsingle=true,
+			trackworker="30l45r",
+			conn_map = {2,1,4,3},
+		},
+
+	},
+	regtp=true,
+	tpdefault="30l45r",
+	rotation={""},
+	trackworker = {
+		["30l45r"] = "60l30l",
+		["60l30l"] = "60l45r",
+		["60l45r"] = "60l60r",
+		["60l60r"] = "60r45l",
+		["60r45l"] = "60r30r",
+		["60r30r"] = "30r45l",
+		["30r45l"] = "30l45r",
+	}
+}
+
+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
+]]
+
+-- Notify the user if digging the rail is not allowed
+local function can_dig_callback(pos, player)
+	local ok, reason = advtrains.can_dig_or_modify_track(pos)
+	if not ok and player then
+		minetest.chat_send_player(player:get_player_name(), attrans("This track can not be removed!") .. " " .. reason)
+	end
+	return ok
+end
+
+local function append_statemap_suffix(state_map, nnpref, rot)
+	local t = {}
+	for state, nn in pairs(state_map) do
+		t[state] = nnpref .. "_" .. nn .. rot
+	end
+	return t
+end
+
+function advtrains.register_tracks(tracktype, def, preset)
+	if not preset.v25_format then
+		error("advtrains.register_tracks(): A track preset for pre-v2.5 is used with advtrains 2.5+. Mod probably defines own track preset instead of using it from the advtrains.ap table! Please check track mod compatibility!")
+	end
+
+	if preset.regtp then
+		local nnprefix = def.nodename_prefix
+		minetest.register_craftitem(":"..nnprefix.."_placer", {
+			description = def.description,
+			inventory_image = def.texture_prefix.."_placer.png",
+			wield_image = def.texture_prefix.."_placer.png",
+			groups={advtrains_trackplacer=1, digtron_on_place=1},
+			liquids_pointable = false,
+			on_place = function(itemstack, placer, pointed_thing)
+				local name = placer:get_player_name()
+				if not name then
+				   return itemstack, false
+				end
+				if pointed_thing.type=="node" then
+					local pos=pointed_thing.above
+					local upos=vector.subtract(pointed_thing.above, {x=0, y=1, z=0})
+					if not advtrains.check_track_protection(pos, name) then
+						return itemstack, false
+					end
+					if minetest.registered_nodes[minetest.get_node(pos).name] and minetest.registered_nodes[minetest.get_node(pos).name].buildable_to then
+						local s = minetest.registered_nodes[minetest.get_node(upos).name] and minetest.registered_nodes[minetest.get_node(upos).name].walkable
+						if s then
+	--						minetest.chat_send_all(nnprefix)
+							local yaw = placer:get_look_horizontal()
+							advtrains.trackplacer.place_track(pos, nnprefix, name, yaw)
+							if not advtrains.is_creative(name) then
+								itemstack:take_item()
+							end
+						end
+					end
+				end
+				return itemstack, true
+			end,
+		})
+		
+		advtrains.trackplacer.set_default_place_candidate(def.nodename_prefix, def.nodename_prefix.."_"..preset.tpdefault)
+	end
+	if preset.regsp then
+		advtrains.slope.register_placer(def, preset)			
+	end
+	
+	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
+				local img_suffix = suffix..rotation
+				local ndef = advtrains.merge_tables({
+					description=def.description.."("..(var.desc or "any")..rotation..")",
+					drawtype = "mesh",
+					paramtype="light",
+					paramtype2="facedir",
+					walkable = false,
+					selection_box = {
+						type = "fixed",
+						fixed = {-1/2-1/16, -1/2, -1/2, 1/2+1/16, -1/2+2/16, 1/2},
+					},
+					
+					mesh = def.shared_model or (def.models_prefix.."_"..img_suffix..def.models_suffix),
+					tiles = {def.shared_texture or (def.texture_prefix.."_"..img_suffix..".png"), def.second_texture},
+					
+					groups = {
+						attached_node = advtrains.IGNORE_WORLD and 0 or 1,
+						advtrains_track=1,
+						["advtrains_track_"..tracktype]=1,
+						save_in_at_nodedb=1,
+						dig_immediate=2,
+						not_in_creative_inventory=1,
+						not_blocking_trains=1,
+					},
+						
+					can_dig = advtrains.track_can_dig_callback,
+					after_dig_node = advtrains.track_update_callback,
+					after_place_node = advtrains.track_update_callback,
+					
+					at_rail_y = var.rail_y
+				}, def.common or {})
+				
+				if preset.regtp then
+					ndef.drop = def.nodename_prefix.."_placer"
+				end
+				if preset.regsp and var.slope then
+					ndef.drop = def.nodename_prefix.."_slopeplacer"
+				end
+				
+				--connections
+				ndef.at_conns = advtrains.rotate_conn_by(var.conns, (rotid-1)*preset.regstep)
+				-- NEW since 2.5
+				ndef.at_conn_map = var.conn_map
+				
+				local ndef_avt_table = {}
+				
+				if var.switchalt and var.switchst then
+					-- NEW since 2.5
+					ndef.on_rightclick = advtrains.state_node_on_rightclick_callback
+					ndef_avt_table.node_state = var.switchst
+					ndef_avt_table.node_next_state = var.switchalt
+					-- obtain and build statemap
+					local state_map = preset.statemaps[var.stmref]
+					if not state_map then error("On registering "..def.nodename_prefix.."_"..suffix..rotation..", stmref of variant doesn't reference entry in preset.statemaps") end
+					ndef_avt_table.node_state_map = append_statemap_suffix(state_map, def.nodename_prefix, rotation)
+					
+					if var.switchmc then
+						local vswitchalt = var.switchalt
+						ndef.mesecons = {effector = {
+							["action_"..var.switchmc] = function(pos, node) 
+								advtrains.setstate(pos, vswitchalt, node)
+							end,
+							rules=advtrains.meseconrules
+						}}
+					end
+				end
+				
+				local adef={}
+				if def.get_additional_definiton then
+					adef=def.get_additional_definiton(def, preset, suffix, rotation)
+				end
+				ndef = advtrains.merge_tables(ndef, adef)
+				
+				-- insert getstate/setstate functions after merging the additional definitions
+				if ndef_avt_table then
+					ndef.advtrains = advtrains.merge_tables(ndef.advtrains or {}, ndef_avt_table)
+				end
+				
+				-- NEW since 2.5: add appropriate fields for trackworker rotation
+				-- get the next rotation step
+				local num_rots = #preset.rotation
+				if rotid >= num_rots then
+					ndef.advtrains.trackworker_next_rot = def.nodename_prefix.."_"..suffix..preset.rotation[1]
+					ndef.advtrains.trackworker_rot_incr_param2 = true
+				else
+					ndef.advtrains.trackworker_next_rot = def.nodename_prefix.."_"..suffix..preset.rotation[rotid+1]
+				end
+				if var.trackworker then
+					ndef.advtrains.trackworker_next_var = def.nodename_prefix.."_"..var.trackworker..rotation
+				end
+
+				local the_node_name = def.nodename_prefix.."_"..suffix..rotation
+				
+				--trackplacer
+				if preset.regtp and (var.tpsingle or var.tpdouble) then
+					advtrains.trackplacer.register_candidate(
+						def.nodename_prefix,
+						the_node_name,
+						ndef,
+						var.tpsingle,
+						var.tpdouble,
+						true)
+				end
+				
+				-- All set, go ahead and register node!
+				--atdebug("track_reg_helper: Registering ",the_node_name," as",ndef)
+				minetest.register_node(":"..the_node_name, ndef)
+				
+			end
+		end
+	end
+end
+
+-- slope placer. Defined in register_tracks.
+--crafted with rail and gravel
+local sl={}
+function sl.register_placer(def, preset)
+	minetest.register_craftitem(":"..def.nodename_prefix.."_slopeplacer",{
+		description = attrans("@1 Slope", def.description),
+		inventory_image = def.texture_prefix.."_slopeplacer.png",
+		wield_image = def.texture_prefix.."_slopeplacer.png",
+		groups={},
+		on_place = sl.create_slopeplacer_on_place(def, preset)
+	})
+end
+--(itemstack, placer, pointed_thing)
+function sl.create_slopeplacer_on_place(def, preset)
+	return function(istack, player, pt)
+		if not pt.type=="node" then 
+			minetest.chat_send_player(player:get_player_name(), attrans("Can't place: not pointing at node"))
+			return istack 
+		end
+		local pos=pt.above
+		if not pos then 
+			minetest.chat_send_player(player:get_player_name(), attrans("Can't place: not pointing at node"))
+			return istack
+		end
+		local node=minetest.get_node(pos)
+		if not minetest.registered_nodes[node.name] or not minetest.registered_nodes[node.name].buildable_to then
+			minetest.chat_send_player(player:get_player_name(), attrans("Can't place: space occupied!"))
+			return istack
+		end
+		if not advtrains.check_track_protection(pos, player:get_player_name()) then 
+			minetest.record_protection_violation(pos, player:get_player_name())
+			return istack
+		end
+		--determine player orientation (only horizontal component)
+		--get_look_horizontal may not be available
+		local yaw=player.get_look_horizontal and player:get_look_horizontal() or (player:get_look_yaw() - math.pi/2)
+		
+		--rounding unit vectors is a nice way for selecting 1 of 8 directions since sin(30°) is 0.5.
+		local dirvec={x=math.floor(math.sin(-yaw)+0.5), y=0, z=math.floor(math.cos(-yaw)+0.5)}
+		--translate to direction to look up inside the preset table
+		local param2, rot45=({
+			[-1]={
+				[-1]=2,
+				[0]=3,
+				[1]=3,
+				},
+			[0]={
+				[-1]=2,
+				[1]=0,
+				},
+			[1]={
+				[-1]=1,
+				[0]=1,
+				[1]=0,
+				},
+		})[dirvec.x][dirvec.z], dirvec.x~=0 and dirvec.z~=0
+		local lookup=preset.slopeplacer
+		if rot45 then lookup=preset.slopeplacer_45 end
+		
+		--go unitvector forward and look how far the next node is
+		local step=1
+		while step<=lookup.max do
+			local node=minetest.get_node(vector.add(pos, dirvec))
+			--next node solid?
+			if not minetest.registered_nodes[node.name] or not minetest.registered_nodes[node.name].buildable_to or advtrains.is_protected(pos, player:get_player_name()) then 
+				--do slopes of this distance exist?
+				if lookup[step] then
+					if minetest.settings:get_bool("creative_mode") or istack:get_count()>=step then
+						--start placing
+						local placenodes=lookup[step]
+						while step>0 do
+							minetest.set_node(pos, {name=def.nodename_prefix.."_"..placenodes[step], param2=param2})
+							if not minetest.settings:get_bool("creative_mode") then
+								istack:take_item()
+							end
+							step=step-1
+							pos=vector.subtract(pos, dirvec)
+						end
+					else
+						minetest.chat_send_player(player:get_player_name(), attrans("Can't place: Not enough slope items left (@1 required)", step))
+					end
+				else
+					minetest.chat_send_player(player:get_player_name(), attrans("Can't place: There's no slope of length @1",step))
+				end
+				return istack
+			end
+			step=step+1
+			pos=vector.add(pos, dirvec)
+		end
+		minetest.chat_send_player(player:get_player_name(), attrans("Can't place: no supporting node at upper end."))
+		return itemstack
+	end
+end
+
+advtrains.slope=sl
diff --git a/advtrains/trackplacer.lua b/advtrains/trackplacer.lua
index 71eb79c..e6111dc 100644
--- a/advtrains/trackplacer.lua
+++ b/advtrains/trackplacer.lua
@@ -27,21 +27,27 @@ end
 
 -- Register a track node as candidate
 -- tpg: the track place group to register the candidates for
+--        NOTE: This value is automatically added to the node definition (ndef) in field ndef.advtrains.track_place_group!
 -- name, ndef: the node name and node definition table to register
 -- as_single: whether the rail should be considered as candidate for one-endpoint connection
 --            Typically only set for the straight rail variants
 -- as_double: whether the rail should be considered as candidate for two-endpoint connection
 --            Typically set for straights and curves
-function tp.register_candidate(tpg, name, ndef, as_single, as_double)
+-- ignore_2conn_for_legacy_xing: skips the 2-connection assertion - ONLY for compatibility with the legacy crossing nodes, DO NOT USE!
+function tp.register_candidate(tpg, name, ndef, as_single, as_double, ignore_2conn_for_legacy_xing)
+	--atdebug("TP Register candidate:",tpg, name, as_single, as_double)
 	--get or create TP group
 	if not tp.groups[tpg] then
 		tp.groups[tpg] = {double = {}, single1 = {}, single2 = {}, default = {name = name, param2 = 0} }
 		-- note: this causes the first candidate to ever be registered to be the default (which is typically what you want)
+		-- But it can be overwritten using tp.set_default_place_candidate
 	end
 	local g = tp.groups[tpg]
 	
 	-- get conns
-	assert(#ndef.at_conns == 2)
+	if not ignore_2conn_for_legacy_xing then
+		assert(#ndef.at_conns == 2)
+	end
 	local c1, c2 = ndef.at_conns[1].c, ndef.at_conns[2].c
 	local is_symmetrical = (rotate(c1, 8) == c2)
 	
@@ -59,6 +65,21 @@ function tp.register_candidate(tpg, name, ndef, as_single, as_double)
 			g.single2[rotate(c2,i*4)] = {name=name, param2=i}
 		end
 	end
+	
+	-- Set track place group on the node
+	if not ndef.advtrains then
+		ndef.advtrains = {}
+	end
+	ndef.advtrains.track_place_group = tpg
+end
+
+-- Sets the node that is placed by the track placer when there is no track nearby. param2 defaults to 0
+function tp.set_default_place_candidate(tpg, name, param2)
+	if not tp.groups[tpg] then
+		tp.groups[tpg] = {double = {}, single1 = {}, single2 = {}, default = {name = name, param2 = param2 or 0} }
+	else
+		tp.groups[tpg].default = {name = name, param2 = param2 or 0}
+	end
 end
 
 local function check_or_bend_rail(origin, dir, pname, commit)
@@ -87,7 +108,7 @@ local function check_or_bend_rail(origin, dir, pname, commit)
 		return false
 	end
 	-- now the track must be two-conn, else it wouldn't be allowed to have track_place_group set.
-	assert(#conns == 2)
+	--assert(#conns == 2) -- cannot check here, because of legacy crossing hack
 	-- Is player and game allowed to do this?
 	if not advtrains.can_dig_or_modify_track(pos) then
 		return false
@@ -132,6 +153,7 @@ local function check_or_bend_rail(origin, dir, pname, commit)
 end
 
 local function track_place_node(pos, node, ndef)
+	--atdebug("track_place_node: ",pos, node)
 	advtrains.ndb.swap_node(pos, node)
 	local ndef = minetest.registered_nodes[node.name]
 	if ndef and ndef.after_place_node then
@@ -151,14 +173,20 @@ end
 -- The function returns true on success.
 function tp.place_track(pos, tpg, pname, yaw)
 	-- 1. collect neighboring tracks and whether they can be connected
+	--atdebug("tp.place_track(",pos, tpg, pname, yaw,")")
 	local cand = {}
 	for i=0,15 do
 		if check_or_bend_rail(pos, i, pname) then
 			cand[#cand+1] = i
 		end
 	end
+	--atdebug("Candidates: ",cand)
 	-- obtain the group table
 	local g = tp.groups[tpg]
+	if not g then
+		error("tp.place_track: for tpg="..tpg.." couldn't find the group table")
+	end
+	--atdebug("Group table:",g)
 	-- 2. try all possible two-endpoint connections
 	for k1, conn1 in ipairs(cand) do
 		for k2, conn2 in ipairs(cand) do
@@ -167,6 +195,7 @@ function tp.place_track(pos, tpg, pname, yaw)
 				-- the combination the other way round will be run through in a later loop iteration
 				if advtrains.yawToDirection(yaw, conn1, conn2) == conn2 then
 					-- does there exist a suitable double-connection rail?
+					--atdebug("Try double conn: ",conn1, conn2)
 					local node = g.double[conn1.."_"..conn2]
 					if node then
 						check_or_bend_rail(pos, conn1, pname, true)
@@ -187,6 +216,7 @@ function tp.place_track(pos, tpg, pname, yaw)
 		else
 			single = g.single2
 		end
+		--atdebug("Try single conn: ",conn1)
 		local node = single[conn1]
 		if node then
 			check_or_bend_rail(pos, conn1, pname, true)
diff --git a/advtrains/tracks.lua b/advtrains/tracks.lua
index 46ceaf8..1abef59 100644
--- a/advtrains/tracks.lua
+++ b/advtrains/tracks.lua
@@ -222,19 +222,6 @@ function advtrains.register_node_4rot(ori_name, ori_ndef, definition_mangling_fu
 	end
 end
 
-
--- Registers an item to place and automatically connect nearby tracks
-function advtrains.register_track_placer(...)
-
-end
-
--- Registers an item to place and adjust slope tracks
-function advtrains.register_slope_placer(...)
-
-end
-
-
-
 -- track-related helper functions
 
 function advtrains.is_track(nodename)
@@ -255,13 +242,10 @@ function advtrains.get_track_connections(name, param2)
 	if not param2 then noderot=0 end
 	if noderot > 3 then atprint(" get_track_connections: rail has invaild param2 of "..noderot) noderot=0 end
 	
-	local tracktype
-	for k,_ in pairs(nodedef.groups) do
-		local tt=string.match(k, "^advtrains_track_(.+)$")
-		if tt then
-			tracktype=tt
-		end
+	if not nodedef.at_conns then
+		return nil
 	end
+	--atdebug("Track connections of ",name,param2,":",nodedef.at_conns)
 	return advtrains.rotate_conn_by(nodedef.at_conns, noderot*AT_CMAX/4), (nodedef.at_rail_y or 0), tracktype
 end
 
@@ -283,4 +267,4 @@ function advtrains.can_dig_or_modify_track(pos)
 		end
 	end
 	return true
-end
\ No newline at end of file
+end
-- 
cgit v1.2.3