From 5c8962b39bd4f6871ec87a988ac43d7bfad04d2b Mon Sep 17 00:00:00 2001
From: "Y. Wang" <yw05@forksworld.de>
Date: Mon, 11 Apr 2022 16:55:50 +0200
Subject: Implement basic route signaling with Japanese signals for demo

---
 advtrains_signals_japan/.gitignore |   1 +
 advtrains_signals_japan/init.lua   | 419 +++++++++++++++++++++++++++++++++++++
 2 files changed, 420 insertions(+)
 create mode 100644 advtrains_signals_japan/.gitignore
 create mode 100644 advtrains_signals_japan/init.lua

(limited to 'advtrains_signals_japan')

diff --git a/advtrains_signals_japan/.gitignore b/advtrains_signals_japan/.gitignore
new file mode 100644
index 0000000..0969b6b
--- /dev/null
+++ b/advtrains_signals_japan/.gitignore
@@ -0,0 +1 @@
+models/*
diff --git a/advtrains_signals_japan/init.lua b/advtrains_signals_japan/init.lua
new file mode 100644
index 0000000..9ccf66b
--- /dev/null
+++ b/advtrains_signals_japan/init.lua
@@ -0,0 +1,419 @@
+local pole_texture = "advtrains_hud_bg.png^[colorize:#858585:255"
+local signal_face_texture = "advtrains_hud_bg.png^[colorize:#000000:255"
+local pole_radius = 1/16
+local pole_box = {-pole_radius,-1/2,-pole_radius,pole_radius,1/2,pole_radius}
+local light_radius = 1/20
+local signal_width = 6*light_radius
+local signal_thickness = pole_radius*3
+local signal_height = {}
+local signal_box = {}
+local light_red = "advtrains_hud_bg.png^[colorize:red:255"
+local light_yellow = "advtrains_hud_bg.png^[colorize:orange:255"
+local light_green = "advtrains_hud_bg.png^[colorize:lime:255"
+local light_purple = "advtrains_hud_bg.png^[colorize:purple:255"
+local light_distant = light_purple
+local light_off = signal_face_texture
+
+do
+	local model_path_prefix = table.concat({minetest.get_modpath("advtrains_signals_japan"), "models", "advtrains_signals_japan_"}, DIR_DELIM)
+
+	local function vertex(x, y, z)
+		return string.format("v %f %f %f", x, y, z)
+	end
+	local function texture(u, v)
+		return string.format("vt %f %f", u, v)
+	end
+	local function face_element(v, vt)
+		if vt then
+			return string.format("%d/%d", v, vt)
+		end
+		return tonumber(v)
+	end
+	local function face_elements(...)
+		local st = {"f"}
+		local args = {...}
+		local len = #args
+		for i = 1, len, 2 do
+			st[(i+3)/2] = face_element(args[i], args[i+1])
+		end
+		return table.concat(st, " ")
+	end
+	local function sequential_elements(v0, vt0, count)
+		local st = {}
+		for i = 1, count do
+			st[i] = face_element(v0+i, vt0+i)
+		end
+		return table.concat(st, " ")
+	end
+	local function mod_lower(min, a, b)
+		return min + (a-min)%b
+	end
+	local function connect_circular(v0, vt0, count)
+		return "f " .. sequential_elements(v0, vt0, count)
+	end
+	local function connect_cylindrical(v0, vt0, count)
+		local st = {}
+		for i = 0, count-1 do
+			local j = (i+1)%count
+			local v1 = v0+i+1
+			local v2 = v1+count
+			local v3 = v0+j+1
+			local v4 = v3+count
+			local vt1 = vt0+i+1
+			local vt2 = vt1+count+1
+			st[i+1] = face_elements(v1, vt1, v3, vt1+1, v4, vt2+1, v2, vt2)
+		end
+		return table.concat(st, "\n")
+	end
+	local function circular_textures(u0, v0, r, count, total, angular_offset, direction)
+		local st = {}
+		if not angular_offset then
+			angular_offset = 0
+		end
+		if not total then
+			total = count
+		end
+		if not direction then
+			direction = 1
+		end
+		for i = 0, count-1 do
+			local theta = angular_offset + direction*i/total*2*math.pi
+			local u, v = r*math.cos(theta), r*math.sin(theta)
+			st[i+1] = texture(u0+u, v0+v)
+		end
+		return table.concat(st, "\n")
+	end
+	local function rectangular_textures(u0, v0, u1, v1, count)
+		local st = {}
+		local width = u1-u0
+		for i = 0, count do
+			local u = u0+i/count*width
+			st[i+1] = texture(u, v0)
+			st[i+count+2] = texture(u, v1)
+		end
+		return table.concat(st, "\n")
+	end
+
+	-- generate pole model
+	local pole_npolygon = 32
+	local pole_vertex_count = pole_npolygon*2
+	local pole_uv_count = pole_npolygon*3+2
+	local pole_vertices = {}
+	local pole_objdef = {
+		"g pole",
+		"usemtl pole",
+		connect_circular(0, 0, pole_npolygon),
+		connect_circular(pole_npolygon, 0, pole_npolygon),
+		connect_cylindrical(0, pole_npolygon, pole_npolygon),
+	}
+	local pole_uv = {
+		circular_textures(0.5, 0.5, 0.5, pole_npolygon),
+		rectangular_textures(0, 0, 1, 1, pole_npolygon),
+	}
+	for i = 0, pole_npolygon-1 do
+		local theta = i*2/pole_npolygon*math.pi
+		local r = pole_radius
+		local x, z = r*math.sin(theta), r*math.cos(theta)
+		local lower_index = i+1
+		local upper_index = lower_index+pole_npolygon
+		pole_vertices[lower_index] = vertex(x, -0.5, z)
+		pole_vertices[upper_index] = vertex(x, 0.5, z)
+	end
+	pole_vertices = table.concat(pole_vertices, "\n")
+	pole_objdef = table.concat(pole_objdef, "\n")
+	pole_uv = table.concat(pole_uv, "\n")
+	minetest.safe_file_write(model_path_prefix .. "pole.obj", table.concat({pole_vertices, pole_uv, pole_objdef}, "\n"))
+
+	-- generate signals
+	for lightcount = 5, 6 do
+		for rotname, rot in pairs {["0"] = 0, ["30"] = 26.5, ["45"] = 45, ["60"] = 63.5} do
+			local rot = math.rad(rot)
+			local lightradius = 0.05
+			local lightspacing = 0.04
+			local halfwidth = signal_width/2
+			local halfheight = (2+lightcount)*lightradius+(lightcount-1)*lightspacing/2
+			local halfthickness = signal_thickness/2
+			local half_npolygon = pole_npolygon/2
+			local quarter_npolygon = pole_npolygon/4
+			local boxside = math.max(halfwidth, halfthickness*2)
+			signal_height[lightcount] = halfheight*2
+			signal_box[lightcount] = {-boxside, -halfheight, -boxside, boxside, halfheight, boxside}
+
+			local _vertex = vertex
+			local rv = vector.new(0, rot, 0)
+			local function vertex(x, y, z)
+				local v = vector.rotate(vector.new(x, y, z), rv)
+				return _vertex(v.x, v.y, v.z)
+			end
+
+			-- generate signal face
+			local face_vertices = {}
+			local face_uv = {
+				circular_textures(0.5, 0.5+halfheight-3*lightradius, halfwidth, half_npolygon+1, pole_npolygon),
+				circular_textures(0.5, 0.5-halfheight+3*lightradius, halfwidth, half_npolygon+1, pole_npolygon, math.pi),
+				rectangular_textures(0, 0, 1, 1, 2+pole_npolygon),
+			}
+			local face_objdef = {
+				"g face",
+				"usemtl face",
+				connect_circular(pole_vertex_count+2+pole_npolygon, pole_uv_count, 2+pole_npolygon),
+				connect_circular(pole_vertex_count, pole_uv_count, 2+pole_npolygon),
+				connect_cylindrical(pole_vertex_count, pole_uv_count+2+pole_npolygon, 2+pole_npolygon),
+			}
+			local face_vertex_count = 4*half_npolygon+4
+			local face_uv_count = 2*(half_npolygon+1) + 2*(pole_npolygon+3)
+			for i = 0, half_npolygon do
+				local theta = i/half_npolygon*math.pi
+				local r = halfwidth
+				local x, y = r*math.cos(theta), halfheight-3*lightradius+r*math.sin(theta)
+				face_vertices[i+1] = vertex(x, y, -halfthickness)
+				face_vertices[i+2+half_npolygon] = vertex(-x, -y, -halfthickness)
+				face_vertices[i+3+2*half_npolygon] = vertex(x, y, halfthickness)
+				face_vertices[i+4+3*half_npolygon] = vertex(-x, -y, halfthickness)
+			end
+
+			-- generate lights
+			local light_vertices = {}
+			local light_vertex_count = 8*(half_npolygon+1)+pole_npolygon
+			local light_uv = {rectangular_textures(0, 0, 1, 1, half_npolygon)}
+			local light_uv_count = 2*(half_npolygon+1)+pole_npolygon*lightcount
+			local light_objdef_face = {}
+			local light_objdef_main = {
+				"g light",
+				"usemtl light",
+			}
+			for i = 1, lightcount do
+				local x0, y0 = 0, -halfheight + (2*i+1)*lightradius + (i-1)*lightspacing
+				local v0 = light_vertex_count*(i-1)
+				for j = 0, half_npolygon do
+					local theta = j/half_npolygon*math.pi
+					local xs, ys = math.cos(theta), math.sin(theta)
+					for k, v in pairs {
+						{xm = -1, ym = 1, rm = 1, z = 1},
+						{xm = 1, ym = 1, rm = 0.8, z = 1},
+						{xm = -1, ym = 1, rm = 1, z = 2},
+						{xm = 1, ym = 1, rm = 0.8, z = 2},
+						{xm = 1, ym = -1, rm = 1, z = 1},
+						{xm = -1, ym = -1, rm = 0.8, z = 1},
+						{xm = 1, ym = -1, rm = 1, z = 1.5},
+						{xm = -1, ym = -1, rm = 0.8, z = 1.5},
+					} do
+						local x = x0+xs*lightradius*v.xm*v.rm
+						local y = y0+ys*lightradius*v.ym*v.rm
+						light_vertices[v0+(k-1)*(half_npolygon+1)+j+1] = vertex(x, y, -halfthickness*v.z)
+					end
+				end
+				for j = 0, pole_npolygon-1 do
+					local theta = j/pole_npolygon*2*math.pi
+					local x, y = math.cos(theta), math.sin(theta)
+					light_vertices[v0+8*(half_npolygon+1)+1+j] = vertex(x0+lightradius*x, y0+lightradius*y, -halfthickness*1.05)
+				end
+				local v0 = pole_vertex_count+face_vertex_count+v0
+				local vt0 = pole_uv_count + face_uv_count
+				local ostep = 2*half_npolygon+2
+				for j = 1, half_npolygon do
+					local dv = 2*(half_npolygon+1)
+					local v0 = v0 + dv
+					local vn = v0 + dv
+					light_objdef_face[i*ostep-j+1] = face_elements(v0+j, vt0+j, v0+j+1, vt0+j+1, vn-j, vt0+half_npolygon+2+j, vn-j+1, vt0+half_npolygon+1+j)
+					local v0 = vn + dv
+					local vn = v0 + dv
+					light_objdef_face[i*ostep-half_npolygon-j+1] = face_elements(v0+j, vt0+j, v0+j+1, vt0+j+1, vn-j, vt0+half_npolygon+2+j, vn-j+1, vt0+half_npolygon+1+j)
+				end
+				local vt0 = vt0 + 2*(half_npolygon+1) + (i-1)*pole_npolygon
+				light_uv[i+1] = circular_textures(0.5, (i-1/2)/lightcount, 0.4/lightcount, pole_npolygon)
+				light_objdef_face[(i-1)*ostep+1] = connect_cylindrical(v0, pole_uv_count+2+pole_npolygon, 2+pole_npolygon)
+				light_objdef_face[(i-1)*ostep+2] = connect_cylindrical(v0+4*(half_npolygon+1), pole_uv_count+2+pole_npolygon, 2+pole_npolygon)
+				light_objdef_main[2+i] = connect_circular(v0+8*(half_npolygon+1), vt0, pole_npolygon)
+			end
+
+			-- write file
+			face_vertices = table.concat(face_vertices, "\n")
+			face_uv = table.concat(face_uv, "\n")
+			face_objdef = table.concat(face_objdef, "\n")
+			minetest.safe_file_write(model_path_prefix .. lightcount .. "_" .. rotname .. ".obj", table.concat({
+				pole_vertices,
+				face_vertices,
+				table.concat(light_vertices, "\n"),
+				pole_uv,
+				face_uv,
+				table.concat(light_uv, "\n"),
+				pole_objdef,
+				face_objdef,
+				table.concat(light_objdef_face, "\n"),
+				table.concat(light_objdef_main, "\n"),
+			}, "\n"))
+		end
+	end
+end
+
+local S = attrans
+
+minetest.register_node("advtrains_signals_japan:pole_0", {
+	description = S("Japanese signal pole"),
+	drawtype = "mesh",
+	mesh = "advtrains_signals_japan_pole.obj",
+	tiles = {pole_texture},
+
+	paramtype = "light",
+	sunlight_propagates = true,
+
+	paramtype2 = "none",
+	selection_box = {
+		type = "fixed",
+		fixed = {pole_box},
+	},
+	collision_box = {
+		type = "fixed",
+		fixed = {pole_box},
+	},
+	groups = {
+		cracky = 2,
+		not_blocking_trains = 1,
+		not_in_creative_inventory = 0,
+	},
+	drop = "advtrains_signals_japan:pole_0",
+})
+
+local sigdefs = {}
+local lightcolors = {
+	red = "red",
+	green = "lime",
+	yellow = "orange",
+	distant = "purple",
+}
+local aspnames = {
+	danger = "Danger (halt)",
+	restrictedspeed = "Restricted speed",
+	caution = "Caution",
+	reducedspeed = "Reduced speed",
+	clear = "Clear (proceed)",
+}
+local function process_signal(name, sigdata, isrpt)
+	local typename = "advtrains_signals_japan:" .. name
+	local type2def = {}
+	type2def.name = typename
+	type2def.main = {}
+	local def = {}
+	local tx = {}
+	def.typename = typename
+	def.textures = tx
+	def.desc = sigdata.desc
+	def.isdst = isrpt
+	local lights = sigdata.lights
+	local lightcount = #lights
+	if isrpt then
+		lightcount = lightcount+1
+	end
+	def.lightcount = lightcount
+	for idx, asp in ipairs(sigdata.aspects) do
+		local aspname = asp.name
+		local tt = {
+			string.format("[combine:1x%d", lightcount),
+			string.format("0,0=(advtrains_hud_bg.png\\^[resize\\:1x%d\\^[colorize\\:#000)", lightcount),
+		}
+		for _, i in pairs(asp.lights) do
+			local color = lightcolors[lights[i]]
+			tt[#tt+1] = string.format("0,%d=(advtrains_hud_bg.png\\^[colorize\\:%s)", i-1, color)
+		end
+		if isrpt then
+			local color = lightcolors.distant
+			tt[#tt+1] = string.format("0,%d=(advtrains_hud_bg.png\\^[colorize\\:%s)", lightcount-1, color)
+		end
+		tx[aspname] = table.concat(tt, ":")
+		type2def.main[idx] = {name = asp.name, label = S(aspnames[asp.name]), main = asp.main or false}
+	end
+	local invimg = {
+		string.format("[combine:%dx%d", lightcount*4+1, lightcount*4+1),
+		string.format("%d,0=(advtrains_hud_bg.png\\^[resize\\:5x%d\\^[colorize\\:#000)", lightcount*2-2, lightcount*4+1),
+	}
+	for i, c in pairs(lights) do
+		local color = lightcolors[c]
+		invimg[i+2] = string.format("%d,%d=(advtrains_hud_bg.png\\^[resize\\:3x3\\^[colorize\\:%s)", 2*lightcount-1, 4*i-3, color)
+	end
+	if isrpt then
+		invimg[lightcount+2] = string.format("%d,%d=(advtrains_hud_bg.png\\^[resize\\:3x3\\^[colorize\\:%s)", 2*lightcount-1, 4*lightcount-3, lightcolors.distant)
+	end
+	def.inventory_image = table.concat(invimg, ":")
+	if not isrpt then
+		advtrains.interlocking.aspects.register_type2(type2def)
+	end
+	return def
+end
+for sigtype, sigdata in pairs {
+	["5a"] = {
+		desc = "5A",
+		lights = {"yellow", "yellow", "red", "yellow", "green"},
+		aspects = {
+			{name = "clear", lights = {5}, main = -1},
+			{name = "reducedspeed", lights = {2, 5}},
+			{name = "caution", lights = {4}},
+			{name = "restrictedspeed", lights = {1, 4}},
+			{name = "danger", lights = {3}, main = 0},
+		}
+	}
+} do
+	sigdefs["main_"..sigtype] = process_signal(sigtype, sigdata)
+	sigdefs["rpt_"..sigtype] = process_signal(sigtype, sigdata, true)
+end
+
+for k in pairs(sigdefs) do
+	advtrains.trackplacer.register_tracktype("advtrains_signals_japan:"..k)
+end
+
+for _, rtab in ipairs {
+	{rot = "0", ici = true},
+	{rot = "30"},
+	{rot = "45"},
+	{rot = "60"},
+} do
+	local rot = rtab.rot
+	for sigtype, siginfo in pairs(sigdefs) do
+		local lightcount = siginfo.lightcount
+		for asp, texture in pairs(siginfo.textures) do
+			minetest.register_node("advtrains_signals_japan:"..sigtype.."_"..asp.."_"..rot, {
+				description = attrans(string.format("Japanese%s signal (type %s)", siginfo.isdst and " repeating" or "", siginfo.desc)),
+				drawtype = "mesh",
+				mesh = string.format("advtrains_signals_japan_%d_%s.obj", lightcount, rot),
+				tiles = {pole_texture, signal_face_texture, texture},
+				paramtype = "light",
+				sunlight_propagates = true,
+				light_source = 4,
+				paramtype2 = "facedir",
+				selection_box = {
+					type = "fixed",
+					fixed = {pole_box, signal_box[lightcount]},
+				},
+				collision_box = {
+					type = "fixed",
+					fixed = {pole_box, signal_box[lightcount]},
+				},
+				groups = {
+					cracky = 2,
+					advtrains_signal = 2,
+					not_blocking_trains = 1,
+					save_in_at_nodedb = 1,
+					not_in_creative_inventory = rtab.ici and asp == "danger" and 0 or 1,
+				},
+				inventory_image = siginfo.inventory_image,
+				drop = "advtrains_signals_japan:"..sigtype.."_danger_0",
+				advtrains = {
+					supported_aspects = {
+						type = 2,
+						group = siginfo.typename,
+					},
+					get_aspect = function()
+						return asp
+					end,
+					set_aspect = function(pos, node, asp)
+						advtrains.ndb.swap_node(pos, {name = "advtrains_signals_japan:"..sigtype.."_"..asp.."_"..rot, param2 = node.param2})
+					end,
+				},
+				on_rightclick = advtrains.interlocking.signal_rc_handler,
+				can_dig = advtrains.interlocking.signal_can_dig,
+				after_dig_node = advtrains.interlocking.signal_after_dig,
+			})
+			advtrains.trackplacer.add_worked("advtrains_signals_japan:"..sigtype, asp, "_"..rot)
+		end
+	end
+end
-- 
cgit v1.2.3


From 875968f078ef89b13afae6d02a2dabe5ea7897cb Mon Sep 17 00:00:00 2001
From: "Y. Wang" <yw05@forksworld.de>
Date: Sun, 3 Jul 2022 12:45:27 +0200
Subject: Unassign distant signals when canceling route

---
 advtrains_interlocking/routesetting.lua            | 11 +++++++++--
 advtrains_interlocking/signal_api.lua              |  7 ++++++-
 advtrains_interlocking/signal_aspect_accessors.lua |  2 +-
 advtrains_interlocking/signal_aspects.lua          |  4 ++++
 advtrains_signals_japan/init.lua                   |  2 +-
 5 files changed, 21 insertions(+), 5 deletions(-)

(limited to 'advtrains_signals_japan')

diff --git a/advtrains_interlocking/routesetting.lua b/advtrains_interlocking/routesetting.lua
index f1b4455..4ce6fd3 100644
--- a/advtrains_interlocking/routesetting.lua
+++ b/advtrains_interlocking/routesetting.lua
@@ -113,7 +113,7 @@ function ilrs.set_route(signal, route, try)
 			}
 			if c_tcbs.signal then
 				c_tcbs.route_committed = true
-				c_tcbs.aspect = route.aspect or advtrains.interlocking.GENERIC_FREE
+				c_tcbs.aspect = route.aspect or advtrains.interlocking.FULL_FREE
 				c_tcbs.route_origin = signal
 				advtrains.interlocking.update_signal_aspect(c_tcbs)
 				signals[#signals+1] = c_tcbs.signal
@@ -138,7 +138,7 @@ function ilrs.set_route(signal, route, try)
 		if lastsig then
 			local pos = signals[i]
 			local _, assigned_by = advtrains.distant.get_main(pos)
-			if assigned_by ~= "manual" then
+			if not assigned_by or assigned_by == "routesetting" then
 				advtrains.distant.assign(lastsig, signals[i], "routesetting")
 			end
 		end
@@ -251,6 +251,13 @@ function ilrs.cancel_route_from(sigd)
 		c_tcbs.route_origin = nil
 		
 		advtrains.interlocking.update_signal_aspect(c_tcbs)
+		if c_tcbs.signal then
+			local pos = c_tcbs.signal
+			local _, assigned_by = advtrains.distant.get_main(pos)
+			if assigned_by == "routesetting" then
+				advtrains.distant.unassign_dst(pos)
+			end
+		end
 		
 		c_ts_id = c_tcbs.ts_id
 		if not c_tcbs then
diff --git a/advtrains_interlocking/signal_api.lua b/advtrains_interlocking/signal_api.lua
index 1fd4e34..eec70f9 100644
--- a/advtrains_interlocking/signal_api.lua
+++ b/advtrains_interlocking/signal_api.lua
@@ -176,6 +176,11 @@ advtrains.interlocking.GENERIC_FREE = {
 	shunt = false,
 	dst = false,
 }
+advtrains.interlocking.FULL_FREE = {
+	main = -1,
+	shunt = false,
+	proceed_as_main = true,
+}
 
 local function convert_aspect_if_necessary(asp)
 	if type(asp.main) == "table" then
@@ -212,7 +217,7 @@ end
 
 function advtrains.interlocking.signal_after_dig(pos)
 	-- clear influence point
-	advtrains.interlocking.db.clear_ip_by_signalpos(pos)
+
 	advtrains.interlocking.signal_clear_aspect(pos)
 	advtrains.distant.unassign_all(pos, true)
 end
diff --git a/advtrains_interlocking/signal_aspect_accessors.lua b/advtrains_interlocking/signal_aspect_accessors.lua
index 02a03ea..bdbb803 100644
--- a/advtrains_interlocking/signal_aspect_accessors.lua
+++ b/advtrains_interlocking/signal_aspect_accessors.lua
@@ -103,9 +103,9 @@ local function set_aspect(pos, asp)
 		local newasp, aspval = adjust_aspect(pos, asp)
 		set_supposed_aspect(pos, newasp)
 		ndef.advtrains.set_aspect(pos, node, aspval)
+		I.signal_on_aspect_changed(pos)
 		local aspect_changed = A.not_equalp(oldasp, newasp)
 		if aspect_changed then
-			I.signal_on_aspect_changed(pos)
 			D.update_main(pos)
 		end
 	end
diff --git a/advtrains_interlocking/signal_aspects.lua b/advtrains_interlocking/signal_aspects.lua
index 2866ae1..5c4948b 100644
--- a/advtrains_interlocking/signal_aspects.lua
+++ b/advtrains_interlocking/signal_aspects.lua
@@ -32,6 +32,8 @@ local function register_type2(def)
 		t.label = label
 
 		t.main = asp.main
+		t.shunt = asp.shunt
+		t.proceed_as_main = asp.proceed_as_main
 		mainasps[idx] = t
 		mainasps[name] = idx
 	end
@@ -87,6 +89,8 @@ local function type2main_to_type1(name, asp)
 
 	local t = {
 		main = asptbl.main,
+		shunt = asptbl.shunt,
+		proceed_as_main = asptbl.proceed_as_main,
 		type2name = asp,
 		type2group = name,
 		dst = dst,
diff --git a/advtrains_signals_japan/init.lua b/advtrains_signals_japan/init.lua
index 9ccf66b..2062a21 100644
--- a/advtrains_signals_japan/init.lua
+++ b/advtrains_signals_japan/init.lua
@@ -321,7 +321,7 @@ local function process_signal(name, sigdata, isrpt)
 			tt[#tt+1] = string.format("0,%d=(advtrains_hud_bg.png\\^[colorize\\:%s)", lightcount-1, color)
 		end
 		tx[aspname] = table.concat(tt, ":")
-		type2def.main[idx] = {name = asp.name, label = S(aspnames[asp.name]), main = asp.main or false}
+		type2def.main[idx] = {name = asp.name, label = S(aspnames[asp.name]), main = asp.main, proceed_as_main = true}
 	end
 	local invimg = {
 		string.format("[combine:%dx%d", lightcount*4+1, lightcount*4+1),
-- 
cgit v1.2.3


From 30a0f862488a0cb67f9a8e2aecaf17797ad44a93 Mon Sep 17 00:00:00 2001
From: "Y. Wang" <yw05@forksworld.de>
Date: Mon, 24 Oct 2022 13:51:03 +0200
Subject: Properly handle repeater signals

---
 advtrains_interlocking/signal_aspect_accessors.lua | 41 +++++++++++++++++-----
 advtrains_interlocking/signal_aspect_ui.lua        |  2 +-
 advtrains_interlocking/signal_aspects.lua          | 40 +++++++++++++--------
 .../spec/basic_signalling_spec.lua                 |  2 +-
 advtrains_interlocking/tcb_ts_ui.lua               | 28 ++++++++-------
 advtrains_signals_japan/init.lua                   |  1 +
 6 files changed, 77 insertions(+), 37 deletions(-)

(limited to 'advtrains_signals_japan')

diff --git a/advtrains_interlocking/signal_aspect_accessors.lua b/advtrains_interlocking/signal_aspect_accessors.lua
index a1cbd4e..060f923 100644
--- a/advtrains_interlocking/signal_aspect_accessors.lua
+++ b/advtrains_interlocking/signal_aspect_accessors.lua
@@ -4,6 +4,27 @@ local I = advtrains.interlocking
 local N = advtrains.ndb
 local pts = advtrains.roundfloorpts
 
+local signal_aspect_metatable = {
+	__tostring = function(asp)
+		local st = {}
+		if asp.type2group and asp.type2name then
+			table.insert(st, string.format("%q in group %q", asp.type2name, asp.type2group))
+		end
+		if asp.main then
+			table.insert(st, string.format("current %d", asp.main))
+		end
+		if asp.main ~= 0 then
+			if asp.dst then
+				table.insert(st, string.format("next %d", asp.dst))
+			end
+			if asp.proceed_as_main then
+				table.insert(st, "proceed as main")
+			end
+		end
+		return string.format("[%s]", table.concat(st, ", "))
+	end,
+}
+
 local get_aspect
 
 local supposed_aspects = {}
@@ -11,6 +32,9 @@ local supposed_aspects = {}
 function I.load_supposed_aspects(tbl)
 	if tbl then
 		supposed_aspects = tbl
+		for _, v in pairs(tbl) do
+			setmetatable(v, signal_aspect_metatable)
+		end
 	end
 end
 
@@ -41,11 +65,14 @@ end
 
 local function adjust_aspect(pos, asp)
 	asp = table.copy(I.signal_convert_aspect_if_necessary(asp))
+	setmetatable(asp, signal_aspect_metatable)
 
 	local mainpos = D.get_main(pos)
 	local nxtasp
-	if asp.main ~= 0 and mainpos then
+	if mainpos then
 		nxtasp = get_aspect(mainpos)
+	end
+	if asp.main ~= 0 and mainpos then
 		asp.dst = nxtasp.main
 	else
 		asp.dst = nil
@@ -59,7 +86,10 @@ local function adjust_aspect(pos, asp)
 	if stype == 2 then
 		local group = suppasp.group
 		local name
-		if asp.main ~= 0 and nxtasp and nxtasp.type2group == group and nxtasp.type2name then
+		if suppasp.dst_shift and nxtasp then
+			asp.main = nil
+			name = A.type1_to_type2main(nxtasp, group, suppasp.dst_shift)
+		elseif asp.main ~= 0 and nxtasp and nxtasp.type2group == group and nxtasp.type2name then
 			name = A.get_type2_dst(group, nxtasp.type2name)
 		else
 			name = A.type1_to_type2main(asp, group)
@@ -79,7 +109,7 @@ local function get_real_aspect(pos)
 		local asp = ndef.advtrains.get_aspect(pos, node) or I.DANGER
 		local suppasp = get_supported_aspects(pos)
 		if suppasp.type == 2 then
-			asp = A.type2main_to_type1(suppasp.group, asp)
+			asp = A.type2_to_type1(suppasp, asp)
 		end
 		return adjust_aspect(pos, asp)
 	end
@@ -108,11 +138,6 @@ local function set_aspect(pos, asp, skipdst)
 		if (not skipdst) and aspect_changed then
 			D.update_main(pos)
 		end
-		--[[
-		local dbgmsg = string.format("[%s]set_aspect(%s,%s,%s)", os.clock(), minetest.pos_to_string(pos), minetest.serialize(asp), tostring(skipdst))
-		dbgmsg = debug.traceback(dbgmsg, 2)
-		minetest.chat_send_all(dbgmsg)
-		--]]
 	end
 end
 
diff --git a/advtrains_interlocking/signal_aspect_ui.lua b/advtrains_interlocking/signal_aspect_ui.lua
index 30b5165..ccedb01 100644
--- a/advtrains_interlocking/signal_aspect_ui.lua
+++ b/advtrains_interlocking/signal_aspect_ui.lua
@@ -219,7 +219,7 @@ local function get_aspect_from_formspec_t1(suppasp, fields)
 end
 
 local function get_aspect_from_formspec_t2(suppasp, fields)
-	local asp = advtrains.interlocking.aspects.type2main_to_type1(suppasp.group, tonumber(fields.asp))
+	local asp = advtrains.interlocking.aspects.type2_to_type1(suppasp, tonumber(fields.asp))
 	return asp
 end
 
diff --git a/advtrains_interlocking/signal_aspects.lua b/advtrains_interlocking/signal_aspects.lua
index 5c4948b..c381fd2 100644
--- a/advtrains_interlocking/signal_aspects.lua
+++ b/advtrains_interlocking/signal_aspects.lua
@@ -67,7 +67,9 @@ local function get_type2_dst(group, name)
 	return def.main[math.max(1, aspidx-1)].name
 end
 
-local function type2main_to_type1(name, asp)
+local function type2_to_type1(suppasp, asp)
+	local name = suppasp.group
+	local shift = suppasp.dst_shift
 	local def = type2defs[name]
 	if not def then
 		return nil
@@ -78,18 +80,26 @@ local function type2main_to_type1(name, asp)
 	else
 		aspidx = def.main[asp] or 2
 	end
-	local asptbl = def.main[aspidx]
+	local realidx = math.min(#def.main, aspidx+(shift or 0))
+	local asptbl = def.main[realidx]
 	if not asptbl then
 		return nil
 	end
 	if type(asp) == "number" then
 		asp = asptbl.name
 	end
-	local dst = def.main[math.min(#def.main, aspidx+1)].main
+	local main, shunt, dst
+	if shift then
+		dst = asptbl.main
+	else
+		main = asptbl.main
+		shunt = asptbl.shunt
+		dst = def.main[math.min(#def.main, aspidx+1)].main
+	end
 
 	local t = {
-		main = asptbl.main,
-		shunt = asptbl.shunt,
+		main = main,
+		shunt = shunt,
 		proceed_as_main = asptbl.proceed_as_main,
 		type2name = asp,
 		type2group = name,
@@ -101,31 +111,28 @@ local function type2main_to_type1(name, asp)
 	return t
 end
 
-local function type1_to_type2main(asp, group)
+local function type1_to_type2main(asp, group, shift)
 	local def = type2defs[group]
 	if not def then
 		return nil
 	end
-	if group == asp.type2group and def.main[asp.type2name] then
-		return asp.type2name
-	end
 	local t_main = def.main
 	local idx
-	if not asp.main or asp.main == -1 then
+	if group == asp.type2group and t_main[asp.type2name] then
+		idx = t_main[asp.type2name]
+	elseif not asp.main or asp.main == -1 then
 		idx = 1
 	elseif asp.main == 0 then
 		idx = #t_main
 	else
-		idx = math.max(#t_main-1, 1)
+		idx = #t_main-1
 	end
-	return t_main[idx].name
+	return t_main[math.max(1, idx-(shift or 0))].name
 end
 
 local function equalp(asp1, asp2)
 	if asp1 == asp2 then -- same reference
 		return true
-	elseif asp1.type2group and asp1.type2group == asp2.type2group then -- type2 with the same group
-		return asp1.type2name == asp2.type2name
 	else
 		for _, k in pairs {"main", "shunt", "dst"} do
 			if asp1[k] ~= asp2[k] then
@@ -133,6 +140,9 @@ local function equalp(asp1, asp2)
 			end
 		end
 	end
+	if asp1.type2group and asp1.type2group == asp2.type2group then
+		return asp1.type2name == asp2.type2name
+	end
 	return true
 end
 
@@ -144,7 +154,7 @@ return {
 	register_type2 = register_type2,
 	get_type2_definition = get_type2_definition,
 	get_type2_dst = get_type2_dst,
-	type2main_to_type1 = type2main_to_type1,
+	type2_to_type1 = type2_to_type1,
 	type1_to_type2main = type1_to_type2main,
 	equalp = equalp,
 	not_equalp = not_equalp,
diff --git a/advtrains_interlocking/spec/basic_signalling_spec.lua b/advtrains_interlocking/spec/basic_signalling_spec.lua
index 0b79972..720b274 100644
--- a/advtrains_interlocking/spec/basic_signalling_spec.lua
+++ b/advtrains_interlocking/spec/basic_signalling_spec.lua
@@ -44,7 +44,7 @@ world.layout {
 
 describe("API for supposed signal aspects", function()
 	it("should load and save data properly", function()
-		local tbl = {_foo = true}
+		local tbl = {_foo = {}}
 		I.load_supposed_aspects(tbl)
 		assert.same(tbl, I.save_supposed_aspects())
 	end)
diff --git a/advtrains_interlocking/tcb_ts_ui.lua b/advtrains_interlocking/tcb_ts_ui.lua
index 9f88296..3898d73 100755
--- a/advtrains_interlocking/tcb_ts_ui.lua
+++ b/advtrains_interlocking/tcb_ts_ui.lua
@@ -198,20 +198,24 @@ minetest.register_on_punchnode(function(pos, node, player, pointed_thing)
 			if is_signal then
 				local ndef = minetest.registered_nodes[node.name]
 				if ndef and ndef.advtrains and ndef.advtrains.set_aspect then
-					local tcbs = ildb.get_tcbs(sigd)
-					if tcbs then
-						tcbs.signal = pos
-						if not tcbs.signal_name then
-							tcbs.signal_name = "Signal at "..minetest.pos_to_string(sigd.p)
+					if ndef.advtrains.supported_aspects and not ndef.advtrains.supported_aspects.dst_shift then
+						local tcbs = ildb.get_tcbs(sigd)
+						if tcbs then
+							tcbs.signal = pos
+							if not tcbs.signal_name then
+								tcbs.signal_name = "Signal at "..minetest.pos_to_string(sigd.p)
+							end
+							if not tcbs.routes then
+								tcbs.routes = {}
+							end
+							ildb.set_sigd_for_signal(pos, sigd)
+							minetest.chat_send_player(pname, "Configuring TCB: Successfully assigned signal.")
+							advtrains.interlocking.show_ip_form(pos, pname, true)
+						else
+							minetest.chat_send_player(pname, "Configuring TCB: Internal error, TCBS doesn't exist. Aborted.")
 						end
-						if not tcbs.routes then
-							tcbs.routes = {}
-						end
-						ildb.set_sigd_for_signal(pos, sigd)
-						minetest.chat_send_player(pname, "Configuring TCB: Successfully assigned signal.")
-						advtrains.interlocking.show_ip_form(pos, pname, true)
 					else
-						minetest.chat_send_player(pname, "Configuring TCB: Internal error, TCBS doesn't exist. Aborted.")
+						minetest.chat_send_player(pname, "Configuring TCB: Cannot use distant signal. Aborted.")
 					end
 				else
 					minetest.chat_send_player(pname, "Configuring TCB: Cannot use static signals for routesetting. Aborted.")
diff --git a/advtrains_signals_japan/init.lua b/advtrains_signals_japan/init.lua
index 2062a21..59640b1 100644
--- a/advtrains_signals_japan/init.lua
+++ b/advtrains_signals_japan/init.lua
@@ -401,6 +401,7 @@ for _, rtab in ipairs {
 					supported_aspects = {
 						type = 2,
 						group = siginfo.typename,
+						dst_shift = siginfo.isdst and 0,
 					},
 					get_aspect = function()
 						return asp
-- 
cgit v1.2.3


From d61c72002008280d70a7489f806d181250747c9a Mon Sep 17 00:00:00 2001
From: "Y. Wang" <yw05@forksworld.de>
Date: Thu, 3 Nov 2022 15:25:28 +0100
Subject: Add texture for Japanese signal masts

---
 advtrains_signals_japan/init.lua                          |   2 +-
 .../textures/advtrains_signals_japan_mast.png             | Bin 0 -> 411 bytes
 2 files changed, 1 insertion(+), 1 deletion(-)
 create mode 100644 advtrains_signals_japan/textures/advtrains_signals_japan_mast.png

(limited to 'advtrains_signals_japan')

diff --git a/advtrains_signals_japan/init.lua b/advtrains_signals_japan/init.lua
index 59640b1..a28478f 100644
--- a/advtrains_signals_japan/init.lua
+++ b/advtrains_signals_japan/init.lua
@@ -1,4 +1,4 @@
-local pole_texture = "advtrains_hud_bg.png^[colorize:#858585:255"
+local pole_texture = "advtrains_signals_japan_mast.png"
 local signal_face_texture = "advtrains_hud_bg.png^[colorize:#000000:255"
 local pole_radius = 1/16
 local pole_box = {-pole_radius,-1/2,-pole_radius,pole_radius,1/2,pole_radius}
diff --git a/advtrains_signals_japan/textures/advtrains_signals_japan_mast.png b/advtrains_signals_japan/textures/advtrains_signals_japan_mast.png
new file mode 100644
index 0000000..817394d
Binary files /dev/null and b/advtrains_signals_japan/textures/advtrains_signals_japan_mast.png differ
-- 
cgit v1.2.3


From 778c9096ae7e027feae7f72b980cc583b9ec48b2 Mon Sep 17 00:00:00 2001
From: "Y. Wang" <yw05@forksworld.de>
Date: Sun, 6 Nov 2022 10:14:25 +0100
Subject: Optimize textures in previous commits

---
 .../textures/advtrains_signals_japan_mast.png           | Bin 411 -> 180 bytes
 .../textures/advtrains_signals_ks_mast.png              | Bin 455 -> 180 bytes
 2 files changed, 0 insertions(+), 0 deletions(-)

(limited to 'advtrains_signals_japan')

diff --git a/advtrains_signals_japan/textures/advtrains_signals_japan_mast.png b/advtrains_signals_japan/textures/advtrains_signals_japan_mast.png
index 817394d..8d288a9 100644
Binary files a/advtrains_signals_japan/textures/advtrains_signals_japan_mast.png and b/advtrains_signals_japan/textures/advtrains_signals_japan_mast.png differ
diff --git a/advtrains_signals_ks/textures/advtrains_signals_ks_mast.png b/advtrains_signals_ks/textures/advtrains_signals_ks_mast.png
index db28b4f..81b1128 100644
Binary files a/advtrains_signals_ks/textures/advtrains_signals_ks_mast.png and b/advtrains_signals_ks/textures/advtrains_signals_ks_mast.png differ
-- 
cgit v1.2.3


From 2d072cdc67ec3018eaba36b7c79c2b19e574a94d Mon Sep 17 00:00:00 2001
From: "Y. Wang" <yw05@forksworld.de>
Date: Fri, 6 Jan 2023 14:45:03 +0100
Subject: Rework formspecs; add description to JP signal group

---
 advtrains/formspec.lua                      |  47 +++---
 advtrains_interlocking/distant_ui.lua       |  76 ++++-----
 advtrains_interlocking/signal_api.lua       |  75 +++++----
 advtrains_interlocking/signal_aspect_ui.lua | 232 +++++++++++++++++-----------
 advtrains_interlocking/tcb_ts_ui.lua        |   5 -
 advtrains_signals_japan/init.lua            |   1 +
 6 files changed, 252 insertions(+), 184 deletions(-)

(limited to 'advtrains_signals_japan')

diff --git a/advtrains/formspec.lua b/advtrains/formspec.lua
index 743d3f3..8894354 100644
--- a/advtrains/formspec.lua
+++ b/advtrains/formspec.lua
@@ -9,32 +9,28 @@ local function make_list(entries)
 	return table.concat(t, ",")
 end
 
-local function f_button(x, y, w, h, id, text)
-	return sformat("button[%f,%f;%f,%f;%s;%s]", x, y, w, h, id, text)
+local function S_wrapper(f, i0)
+	return function(...)
+		local args = {...}
+		args[i0] = attrans(unpack(args,i0))
+		return f(unpack(args,1,i0))
+	end
 end
 
-local function S_button(x, y, w, h, id, ...)
-	return f_button(x, y, w, h, id, attrans(...))
+local function f_button(x, y, w, id, text)
+	return sformat("button[%f,%f;%f,0.75;%s;%s]", x, y, w, id, text)
 end
 
 local function f_checkbox(x, y, name, selected, label)
-	return sformat("checkbox[%f,%f;%s;%s;%s]", x, y, name, label, selected and "true" or "false")
-end
-
-local function S_checkbox(x, y, name, selected, ...)
-	return f_checkbox(x, y, name, selected, attrans(...))
+	return sformat("checkbox[%f,%f;%s;%s;%s]", x, y+0.25, name, label, selected and "true" or "false")
 end
 
-local function f_button_exit(x, y, w, h, id, text)
-	return sformat("button_exit[%f,%f;%f,%f;%s;%s]", x, y, w, h, id, text)
-end
-
-local function S_button_exit(x, y, w, h, id, ...)
-	return f_button_exit(x, y, w, h, id, attrans(...))
+local function f_button_exit(x, y, w, id, text)
+	return sformat("button_exit[%f,%f;%f,0.75;%s;%s]", x, y, w, id, text)
 end
 
 local function f_dropdown(x, y, w, id, entries, sel, indexed)
-	return sformat("dropdown[%f,%f;%f;%s;%s;%d%s]",
+	return sformat("dropdown[%f,%f;%f,0.75;%s;%s;%d%s]",
 		x, y, w, id, make_list(entries),
 		sel or 1,
 		indexed and ";true" or "")
@@ -56,11 +52,15 @@ local function f_image_button_exit(x, y, w, h, texture, id, label)
 end
 
 local function f_label(x, y, text)
-	return sformat("label[%f,%f;%s]", x, y, fsescape(text))
+	return sformat("label[%f,%f;%s]", x, y+0.25, fsescape(text))
+end
+
+local function f_field_aux(x, y, w, id, default)
+	return sformat("field[%f,%f;%f,0.75;%s;;%s]", x, y, w, id, default)
 end
 
-local function S_label(x, y, ...)
-	return f_label(x, y, attrans(...))
+local function f_field(x, y, w, id, label, default)
+	return f_label(x, y-0.5, label) .. f_field_aux(x, y, w, id, default)
 end
 
 local function f_tabheader(x, y, w, h, id, entries, sel, transparent, border)
@@ -95,16 +95,17 @@ end
 
 return {
 	button = f_button,
-	S_button = S_button,
+	S_button = S_wrapper(f_button, 5),
 	checkbox = f_checkbox,
-	S_checkbox = S_checkbox,
+	S_checkbox = S_wrapper(f_checkbox, 5),
 	button_exit = f_button_exit,
-	S_button_exit = S_button_exit,
+	S_button_exit = S_wrapper(f_button_exit, 5),
 	dropdown = f_dropdown,
+	field = f_field,
 	image_button = f_image_button,
 	image_button_exit = f_image_button_exit,
 	label = f_label,
-	S_label = S_label,
+	S_label = S_wrapper(f_label, 3),
 	tabheader = f_tabheader,
 	textlist = f_textlist,
 }
diff --git a/advtrains_interlocking/distant_ui.lua b/advtrains_interlocking/distant_ui.lua
index a7ff406..0907684 100644
--- a/advtrains_interlocking/distant_ui.lua
+++ b/advtrains_interlocking/distant_ui.lua
@@ -2,39 +2,52 @@ local F = advtrains.formspec
 local D = advtrains.distant
 local I = advtrains.interlocking
 
-function advtrains.interlocking.show_distant_signal_form(pos, pname)
-	local form = {"size[7,6.5]"}
-	form[#form+1] = advtrains.interlocking.make_signal_formspec_tabheader(pname, pos, 7, 3)
+function I.make_short_dst_formspec_component(pos, x, y, w)
 	local main, set_by = D.get_main(pos)
 	if main then
 		local pts_main = minetest.pos_to_string(main)
-		form[#form+1] = F.S_label(0.5, 0.5, "This signal is a distant signal of @1.", pts_main)
+		local desc = attrans("The assignment is made with an unknown method.")
 		if set_by == "manual" then
-			form[#form+1] = F.S_label(0.5, 1, "The assignment is made manually.")
+			desc = attrans("The assignment is made manually.")
 		elseif set_by == "routesetting" then
-			form[#form+1] = F.S_label(0.5, 1, "The assignment is made by the routesetting system.")
+			desc = attrans("The assignment is made by the routesetting system.")
 		end
+		return table.concat {
+			F.S_label(x, y, "This signal is a distant signal of @1.", pts_main),
+			F.label(x, y+0.5, desc),
+			F.S_button_exit(x, y+1, w/2-0.125, "dst_assign", "Reassign"),
+			F.S_button_exit(x+w/2+0.125, y+1, w/2-0.125, "dst_unassign", "Unassign"),
+		}
 	else
-		form[#form+1] = F.S_label(0.5, 0.5, "This signal is not assigned to a main signal.")
-		form[#form+1] = F.S_label(0.5, 1, "The distant aspect of the signal is not used.")
-	end
-	if set_by ~= nil then
-		form[#form+1] = F.S_button_exit(0.5, 1.5, 3, 1, "unassign_dst", "Unassign")
-		form[#form+1] = F.S_button_exit(3.5, 1.5, 3, 1, "assign_dst", "Reassign")
-	else
-		form[#form+1] = F.S_button_exit(0.5, 1.5, 6, 1, "assign_dst", "Assign")
+		return table.concat {
+			F.S_label(x, y, "This signal is not assigned to a main signal."),
+			F.S_label(x, y+0.5, "The distant aspect of the signal is not used."),
+			F.S_button_exit(x, y+1, w, "dst_assign", "Assign")
+		}
 	end
+end
 
-	local dsts = D.get_dst(pos)
+function I.make_dst_list_formspec_component(pos, x, y, w, h)
+	local ymid = y+0.25+h/2
 	local dstlist = {}
-	for pos, _ in pairs(dsts) do
-		dstlist[#dstlist+1] = minetest.pos_to_string(advtrains.decode_pos(pos))
+	for pos, _ in pairs(D.get_dst(pos)) do
+		table.insert(dstlist, minetest.pos_to_string(advtrains.decode_pos(pos)))
 	end
-	form[#form+1] = F.S_label(0.5, 2.5, "This signal has the following distant signals:")
-	form[#form+1] = F.textlist(0.5, 3, 4.5, 3, "dstlist", dstlist)
-	form[#form+1] = F.image_button_exit(5.5, 3.25, 1, 1, "cdb_add.png", "dst_add", "")
-	form[#form+1] = F.image_button_exit(5.5, 4.75, 1, 1, "cdb_clear.png", "dst_del", "")
-	minetest.show_formspec(pname, "advtrains:distant_" .. minetest.pos_to_string(pos), table.concat(form))
+	return table.concat {
+		F.S_label(x, y, "Distant signals:"),
+		F.textlist(x, y+0.5, w-1, h-0.5, "dstlist", dstlist),
+		F.image_button_exit(x+w-0.75, ymid-0.875, 0.75, 0.75, "cdb_add.png", "dst_add", ""),
+		F.image_button_exit(x+w-0.75, ymid+0.125, 0.75, 0.75, "cdb_clear.png", "dst_del", ""),
+	}
+end
+
+function I.make_dst_formspec_component(pos, x, y, w, h)
+	return I.make_short_dst_formspec_component(pos, x, y, w, h)
+		.. I.make_dst_list_formspec_component(pos, x, y+2, w, h-2)
+end
+
+function I.show_distant_signal_form(pos, pname)
+	return I.show_ip_form(pos, pname)
 end
 
 local signal_pos = {}
@@ -87,21 +100,14 @@ minetest.register_on_punchnode(function(pos, node, player, pointed_thing)
 end)
 
 local dstsel = {}
-minetest.register_on_player_receive_fields(function(player, formname, fields)
-	local pname = player:get_player_name()
-	local pos = minetest.string_to_pos(string.match(formname, "^advtrains:distant_(.+)$") or "")
-	if not pos then
-		return
-	end
-	if not minetest.check_player_privs(pname, "interlocking") then
+
+function advtrains.interlocking.handle_dst_formspec_fields(pname, pos, fields)
+	if not (pos and minetest.check_player_privs(pname, "interlocking")) then
 		return
 	end
-	if advtrains.interlocking.handle_signal_formspec_tabheader_fields(pname, fields) then
-		return true
-	end
-	if fields.unassign_dst then
+	if fields.dst_unassign then
 		D.unassign_dst(pos)
-	elseif fields.assign_dst then
+	elseif fields.dst_assign then
 		init_signal_assignment(pname, pos)
 	elseif fields.dst_add then
 		init_distant_assignment(pname, pos)
@@ -124,4 +130,4 @@ minetest.register_on_player_receive_fields(function(player, formname, fields)
 			end
 		end
 	end
-end)
+end
diff --git a/advtrains_interlocking/signal_api.lua b/advtrains_interlocking/signal_api.lua
index 8bb92bf..cd408d7 100644
--- a/advtrains_interlocking/signal_api.lua
+++ b/advtrains_interlocking/signal_api.lua
@@ -1,5 +1,7 @@
 -- Signal API implementation
 
+local F = advtrains.formspec
+
 local DANGER = {
 	main = 0,
 	shunt = false,
@@ -131,57 +133,68 @@ local function ipmarker(ipos, connid)
 	})
 end
 
--- shows small info form for signal IP state/assignment
+function advtrains.interlocking.make_ip_formspec_component(pos, x, y, w)
+	advtrains.interlocking.db.check_for_duplicate_ip(pos)
+	local pts, connid = advtrains.interlocking.db.get_ip_by_signalpos(pos)
+	if pts then
+		return table.concat {
+			F.S_label(x, y, "Influence point is set at @1.", string.format("%s/%s", pts, connid)),
+			F.S_button_exit(x, y+0.5, w/2-0.125, "ip_set", "Modify"),
+			F.S_button_exit(x+w/2+0.125, y+0.5, w/2-0.125, "ip_clear", "Clear"),
+		}, pts, connid
+	else
+		return table.concat {
+			F.S_label(x, y, "Influence point is not set."),
+			F.S_button_exit(x, y+0.5, w, "ip_set", "Set influence point"),
+		}
+	end
+end
+
+-- shows small info form for signal properties
+-- This function is named show_ip_form because it was originally only intended
+-- for assigning/changing the influence point.
 -- only_notset: show only if it is not set yet (used by signal tcb assignment)
 function advtrains.interlocking.show_ip_form(pos, pname, only_notset)
 	if not minetest.check_player_privs(pname, "interlocking") then
 		return
 	end
-	local form = "size[7,6.5]label[0.5,0.5;Signal at "..minetest.pos_to_string(pos).."]"
-	local node = advtrains.ndb.get_node(pos)
-	local ndef = minetest.registered_nodes[node.name] or {}
-	if ndef.advtrains and ndef.advtrains.set_aspect then
-		form = form .. advtrains.interlocking.make_signal_formspec_tabheader(pname, pos, 7, 2)
-	end
-	advtrains.interlocking.db.check_for_duplicate_ip(pos)
-	local pts, connid = advtrains.interlocking.db.get_ip_by_signalpos(pos)
+	local ipform, pts, connid = advtrains.interlocking.make_ip_formspec_component(pos, 0.5, 0.5, 7)
+	local form = table.concat {
+		"formspec_version[4]",
+		"size[8,6.75]",
+		ipform,
+		advtrains.interlocking.make_dst_formspec_component(pos, 0.5, 2, 7, 4.25),
+	}
 	if pts then
-		form = form.."label[0.5,1.5;Influence point is set at "..pts.."/"..connid.."]"
-		form = form.."button_exit[0.5,4.25;  6,1;set;Move]"
-		form = form.."button_exit[0.5,5.25;  6,1;clear;Clear]"
 		local ipos = minetest.string_to_pos(pts)
 		ipmarker(ipos, connid)
-	else
-		form = form.."label[0.5,1.5;Influence point is not set.]"
-		form = form.."label[0.5,2.0;It is recommended to set an influence point.]"
-		form = form.."label[0.5,2.5;This is the point where trains will obey the signal.]"
-		
-		form = form.."button_exit[0.5,5.25;  6,1;set;Set]"
 	end
 	if not only_notset or not pts then
-		minetest.show_formspec(pname, "at_il_ipassign_"..minetest.pos_to_string(pos), form)
+		minetest.show_formspec(pname, "at_il_propassign_"..minetest.pos_to_string(pos), form)
 	end
 end
 
-minetest.register_on_player_receive_fields(function(player, formname, fields)
-	local pname = player:get_player_name()
-	if advtrains.interlocking.handle_signal_formspec_tabheader_fields(pname, fields) then
-		return true
-	end
-	if not minetest.check_player_privs(pname, {train_operator=true, interlocking=true}) then
+function advtrains.interlocking.handle_ip_formspec_fields(pname, pos, fields)
+	if not (pos and minetest.check_player_privs(pname, {train_operator=true, interlocking=true})) then
 		return
 	end
-	local pts = string.match(formname, "^at_il_ipassign_([^_]+)$")
+	if fields.ip_set then
+		advtrains.interlocking.signal_init_ip_assign(pos, pname)
+	elseif fields.ip_clear then
+		advtrains.interlocking.db.clear_ip_by_signalpos(pos)
+	end
+end
+
+minetest.register_on_player_receive_fields(function(player, formname, fields)
+	local pname = player:get_player_name()
+	local pts = string.match(formname, "^at_il_propassign_([^_]+)$")
 	local pos
 	if pts then
 		pos = minetest.string_to_pos(pts)
 	end
 	if pos then
-		if fields.set then
-			advtrains.interlocking.signal_init_ip_assign(pos, pname)
-		elseif fields.clear then
-			advtrains.interlocking.db.clear_ip_by_signalpos(pos)
-		end
+		advtrains.interlocking.handle_ip_formspec_fields(pname, pos, fields)
+		advtrains.interlocking.handle_dst_formspec_fields(pname, pos, fields)
 	end
 end)
 
diff --git a/advtrains_interlocking/signal_aspect_ui.lua b/advtrains_interlocking/signal_aspect_ui.lua
index 6de21e6..ddab793 100644
--- a/advtrains_interlocking/signal_aspect_ui.lua
+++ b/advtrains_interlocking/signal_aspect_ui.lua
@@ -37,6 +37,20 @@ advtrains.interlocking.describe_t1_main_aspect = describe_t1_main_aspect
 advtrains.interlocking.describe_t1_shunt_aspect = describe_t1_shunt_aspect
 advtrains.interlocking.describe_t1_distant_aspect = describe_t1_distant_aspect
 
+local function dsel(p, q, x, y)
+	if p == nil then
+		if q then
+			return x
+		else
+			return y
+		end
+	elseif p then
+		return x
+	else
+		return y
+	end
+end
+
 local function describe_supported_aspects_t1(suppasp, isasp)
 	local t = {}
 
@@ -50,11 +64,22 @@ local function describe_supported_aspects_t1(suppasp, isasp)
 	end
 	t.main = entries
 	t.main_current = selid
+	t.main_string = tostring(isasp.main)
+	if t.main == nil then
+		t.main_string = ""
+	end
 
-	if suppasp.shunt == nil then
-		t.shunt = true
-		t.shunt_current = isasp and isasp.shunt
+	t.shunt = {
+		attrans("No shunting"),
+		attrans("Shunting allowed"),
+		attrans("Proceed as main"),
+	}
+
+	t.shunt_current = dsel(suppasp.shunt, isasp.shunt, 2, 1)
+	if dsel(suppasp.proceed_as_main, isasp.proceed_as_main, t.shunt_current == 1) then
+		t.shunt_current = 3
 	end
+	t.shunt_const = suppasp.shunt ~= nil
 
 	entries = {}
 	selid = 1
@@ -71,96 +96,98 @@ end
 
 advtrains.interlocking.describe_supported_aspects_t1 = describe_supported_aspects_t1
 
-local signal_tabheader_map = {}
-
-local function make_signal_formspec_tabheader(pname, pos, width, selid)
-	signal_tabheader_map[pname] = pos
-	local firstlabel = attrans("Signal aspect")
-	if advtrains.interlocking.db.get_sigd_for_signal(pos) then
-		firstlabel = attrans("Routesetting")
-	end
-	local options = {
-		firstlabel,
-		attrans("Influence point"),
-		attrans("Distant signalling"),
-	}
-	return F.tabheader(0, 0, nil, nil, "signal_tab", options, selid)
-end
-
-local function handle_signal_formspec_tabheader_fields(pname, fields)
-	local n = tonumber(fields.signal_tab)
-	local pos = signal_tabheader_map[pname]
-	if not (n and pos) then
-		return false
-	end
-	if n == 1 then
-		local node = advtrains.ndb.get_node(pos)
-		advtrains.interlocking.show_signal_form(pos, node, pname)
-	elseif n == 2 then
-		advtrains.interlocking.show_ip_form(pos, pname)
-	elseif n == 3 then
-		advtrains.interlocking.show_distant_signal_form(pos, pname)
-	end
-	return true
-end
-
-advtrains.interlocking.make_signal_formspec_tabheader = make_signal_formspec_tabheader
-advtrains.interlocking.handle_signal_formspec_tabheader_fields = handle_signal_formspec_tabheader_fields
-
 local function make_signal_aspect_selector_t1(suppasp, purpose, isasp)
-	local form = {"size[7,6.5]"}
 	local t = describe_supported_aspects_t1(suppasp, isasp)
+	local formmode = 1
+
+	local pos
 	if type(purpose) == "table" then
-		form[#form+1] = make_signal_formspec_tabheader(purpose.pname, purpose.pos, 7, 1)
-		purpose = ""
+		formmode = 2
+		pos = purpose.pos
 	end
-	form[#form+1] = F.S_label(0.5, 0.5, "Select signal aspect")
-	form[#form+1] = F.label(0.5, 1, purpose)
 
-	form[#form+1] = F.S_label(0.5, 1.5, "Main aspect")
-	form[#form+1] = F.dropdown(0.5, 2, 6, "main", t.main, t.main_current, true)
+	local form = {
+		"formspec_version[4]",
+		string.format("size[8,%f]", ({5.75, 9.25})[formmode]),
+		F.S_label(0.5, 0.5, "Select signal aspect"),
+	}
+	if formmode == 1 then
+		form[#form+1] = F.label(0.5, 1, purpose)
+	else
+		form[#form+1] = F.S_label(0.5, 1, "Signal at @1", minetest.pos_to_string(pos))
+	end
 
-	form[#form+1] = F.S_label(0.5, 3, "Distant aspect")
-	form[#form+1] = F.dropdown(0.5, 3.5, 6, "dst", t.dst, t.dst_current, true)
+	form[#form+1] = F.S_label(0.5, 1.5, "Main aspect")
+	if formmode == 1 then
+		form[#form+1] = F.field(0.5, 2, 7, "asp_mainval", "", t.main_string)
+	else
+		form[#form+1] = F.dropdown(0.5, 2, 7, "asp_mainsel", t.main, t.main_current, true)
+	end
 
-	if t.shunt then
-		form[#form+1] = F.S_checkbox(0.5, 4.25, "shunt", t.shunt_current, "Allow shunting")
+	form[#form+1] = F.S_label(0.5, 3, "Shunt aspect")
+	if formmode == 2 and t.shunt_const then
+		form[#form+1] = F.label(0.5, 3.5, t.shunt[t.shunt_current])
+		form[#form+1] = F.S_label(0.5, 4, "The shunt aspect cannot be changed.")
 	else
-		form[#form+1] = F.S_label(0.5, 4.5, "The shunt aspect cannot be changed.")
+		form[#form+1] = F.dropdown(0.5, 3.5, 7, "asp_shunt", t.shunt, t.shunt_current, true)
+	end
+
+	form[#form+1] = F.S_button_exit(0.5, 4.5, 7, "asp_save", "Save signal aspect")
+
+	if formmode == 2 then
+		form[#form+1] = advtrains.interlocking.make_ip_formspec_component(pos, 0.5, 5.5, 7)
+		form[#form+1] = advtrains.interlocking.make_short_dst_formspec_component(pos, 0.5, 7, 7)
 	end
 
-	form[#form+1] = F.S_button_exit(0.5, 5.25, 6, 1, "save", "Save signal aspect")
 	return table.concat(form)
 end
 
 local function make_signal_aspect_selector_t2(suppasp, purpose, isasp)
-	local form = {"size[7,6.5]"}
 	local def = advtrains.interlocking.aspects.get_type2_definition(suppasp.group)
 	if not def then
 		return nil
 	end
+	local formmode = 1
+
+	local pos
 	if type(purpose) == "table" then
-		form[#form+1] = make_signal_formspec_tabheader(purpose.pname, purpose.pos, 7, 1)
-		purpose = ""
+		formmode = 2
+		pos = purpose.pos
+	end
+	local form = {
+		"formspec_version[4]",
+		string.format("size[8,%f]", ({4.25, 10.25})[formmode]),
+		F.S_label(0.5, 0.5, "Select signal aspect")
+	}
+	if formmode == 1 then
+		form[#form+1] = F.label(0.5, 1, purpose)
+	else
+		form[#form+1] = F.S_label(0.5, 1, "Signal at @1", minetest.pos_to_string(pos))
 	end
-	form[#form+1] = F.S_label(0.5, 0.5, "Select signal aspect")
-	form[#form+1] = F.label(0.5, 1, purpose)
 
 	local entries = {}
-	local selid = 1
-	for idx, spv in ipairs(def.main) do
-		if isasp and isasp.type2name == spv.name then
-			selid = idx
+	local selid = #def.main
+	if isasp then
+		if isasp.type2name ~= def.main[selid].name then
+			selid = 1
 		end
-		entries[idx] = spv.label
 	end
+	if selid > 1 then
+		selid = 2
+	end
+	local entries = {
+		def.main[1].label,
+		def.main[#def.main].label,
+	}
 	form[#form+1] = F.S_label(0.5, 1.5, "Signal group: @1", def.label)
-	form[#form+1] = F.dropdown(0.5, 2, 6, "asp", entries, selid, true)
-	form[#form+1] = F.S_label(0.5, 3, "Aspect in effect:")
-	form[#form+1] = F.label(0.5, 3.5, describe_t1_main_aspect(isasp.main))
-	form[#form+1] = F.label(0.5, 4, describe_t1_distant_aspect(isasp.dst))
-	form[#form+1] = F.label(0.5, 4.5, describe_t1_shunt_aspect(isasp.shunt))
-	form[#form+1] = F.S_button_exit(0.5, 5.25, 6, 1, "save", "Save signal aspect")
+	form[#form+1] = F.dropdown(0.5, 2, 7, "asp_sel", entries, selid, true)
+	form[#form+1] = F.S_button_exit(0.5, 3, 7, "asp_save", "Save signal aspect")
+
+	if formmode == 2 then
+		form[#form+1] = advtrains.interlocking.make_ip_formspec_component(pos, 0.5, 4, 7)
+		form[#form+1] = advtrains.interlocking.make_dst_formspec_component(pos, 0.5, 5.5, 7, 4.25)
+	end
+
 	return table.concat(form)
 end
 
@@ -188,13 +215,14 @@ function advtrains.interlocking.show_signal_aspect_selector(pname, p_suppasp, p_
 
 	local token = advtrains.random_id()
 	minetest.show_formspec(pname, "at_il_sigaspdia_"..token, form)
-	--minetest.after(1, function()
-	players_aspsel[pname] = {
-		suppasp = suppasp,
-		callback = callback,
-		token = token,
-	}
-	--end)
+	minetest.after(0, function()
+		players_aspsel[pname] = {
+			purpose = purpose,
+			suppasp = suppasp,
+			callback = callback,
+			token = token,
+		}
+	end)
 end
 
 local function usebool(sup, val, free)
@@ -206,20 +234,45 @@ local function usebool(sup, val, free)
 end
 
 local function get_aspect_from_formspec_t1(suppasp, fields, psl)
-	local maini = tonumber(fields.main)
-	if not maini then return end
-	local dsti = tonumber(fields.dst)
-	if not dsti then return end
+	local maini = tonumber(fields.asp_mainsel)
+	local main = suppasp.main[maini]
+	if not maini then
+		local mainval = fields.asp_mainval
+		if mainval == "-1" then
+			main = -1
+		elseif string.match(mainval, "^%d+$") then
+			main = tonumber(mainval)
+		else
+			main = nil
+		end
+	end
+	local shunti = tonumber(fields.asp_shunt)
+	local shunt = suppasp.shunt
+	if shunt == nil then
+		shunt = shunti == 2
+	end
+	local proceed_as_main = suppasp.proceed_as_main
+	if proceed_as_main == nil then
+		proceed_as_main = shunti == 3
+	end
 	return {
-		main = suppasp.main[maini],
-		dst = suppasp.dst[dsti],
-		shunt = usebool(suppasp.shunt, psl.shunt, "true"),
+		main = main,
+		shunt = shunt,
+		proceed_as_main = proceed_as_main,
 		info = {},
 	}
 end
 
 local function get_aspect_from_formspec_t2(suppasp, fields, psl)
-	local asp = advtrains.interlocking.aspects.type2_to_type1(suppasp, tonumber(fields.asp))
+	local sel = tonumber(fields.asp_sel)
+	local def = advtrains.interlocking.aspects.get_type2_definition(suppasp.group)
+	if not (sel and def) then
+		return
+	end
+	if sel ~= 1 then
+		sel = #def.main
+	end
+	local asp = advtrains.interlocking.aspects.type2_to_type1(suppasp, sel)
 	return asp
 end
 
@@ -229,13 +282,7 @@ minetest.register_on_player_receive_fields(function(player, formname, fields)
 	if psl then
 		if formname == "at_il_sigaspdia_"..psl.token then
 			local suppasp = psl.suppasp
-			if handle_signal_formspec_tabheader_fields(pname, fields) then
-				return true
-			end
-			if fields.shunt then
-				psl.shunt = fields.shunt
-			end
-			if fields.save then
+			if fields.asp_save then
 				local asp
 				if suppasp.type == 2 then
 					asp = get_aspect_from_formspec_t2(suppasp, fields, psl)
@@ -246,6 +293,11 @@ minetest.register_on_player_receive_fields(function(player, formname, fields)
 					psl.callback(pname, asp)
 				end
 			end
+			if type(psl.purpose) == "table" then
+				local pos = psl.purpose.pos
+				advtrains.interlocking.handle_ip_formspec_fields(pname, pos, fields)
+				advtrains.interlocking.handle_dst_formspec_fields(pname, pos, fields)
+			end
 		else
 			players_aspsel[pname] = nil
 		end
diff --git a/advtrains_interlocking/tcb_ts_ui.lua b/advtrains_interlocking/tcb_ts_ui.lua
index 3898d73..9aea18c 100755
--- a/advtrains_interlocking/tcb_ts_ui.lua
+++ b/advtrains_interlocking/tcb_ts_ui.lua
@@ -614,7 +614,6 @@ function advtrains.interlocking.show_signalling_form(sigd, pname, sel_rte, calle
 	if not tcbs.routes then tcbs.routes = {} end
 	
 	local form = "size[7,10.25]label[0.5,0.5;Signal at "..minetest.pos_to_string(sigd.p).."]"
-	form = form .. advtrains.interlocking.make_signal_formspec_tabheader(pname, tcbs.signal, 7, 1)
 	form = form.."field[0.8,1.5;5.2,1;name;Signal name;"..minetest.formspec_escape(tcbs.signal_name).."]"
 	form = form.."button[5.5,1.2;1,1;setname;Set]"
 	
@@ -708,10 +707,6 @@ end
 
 minetest.register_on_player_receive_fields(function(player, formname, fields)
 	local pname = player:get_player_name()
-	if string.find(formname, "^at_il_signalling_")
-		and advtrains.interlocking.handle_signal_formspec_tabheader_fields(pname, fields) then
-		return true
-	end
 	if not minetest.check_player_privs(pname, "train_operator") then
 		return
 	end
diff --git a/advtrains_signals_japan/init.lua b/advtrains_signals_japan/init.lua
index a28478f..fe74259 100644
--- a/advtrains_signals_japan/init.lua
+++ b/advtrains_signals_japan/init.lua
@@ -294,6 +294,7 @@ local function process_signal(name, sigdata, isrpt)
 	local type2def = {}
 	type2def.name = typename
 	type2def.main = {}
+	type2def.label = S(string.format("Japanese signal (type %s)", string.upper(name)))
 	local def = {}
 	local tx = {}
 	def.typename = typename
-- 
cgit v1.2.3


From e25b1c744dad7daa561ee0b23b006bc616f88f23 Mon Sep 17 00:00:00 2001
From: "Y. Wang" <yw05@forksworld.de>
Date: Sun, 26 Mar 2023 11:53:00 +0200
Subject: Cancel type 2 signals; introduce signal groups for all signals

---
 advtrains_interlocking/README.md                   |  41 ++-
 advtrains_interlocking/aspect.lua                  | 290 +++++++++++++++++++++
 advtrains_interlocking/distant.lua                 |   1 -
 advtrains_interlocking/init.lua                    |   2 +-
 advtrains_interlocking/signal_api.lua              |  28 +-
 advtrains_interlocking/signal_aspect_accessors.lua |  80 ++----
 advtrains_interlocking/signal_aspect_ui.lua        | 127 ++-------
 advtrains_interlocking/signal_aspects.lua          | 202 --------------
 .../spec/basic_signalling_spec.lua                 |  26 +-
 advtrains_interlocking/spec/signal_group_spec.lua  |  95 +++++++
 advtrains_interlocking/spec/type2_spec.lua         | 117 ---------
 advtrains_signals_japan/init.lua                   |  18 +-
 12 files changed, 474 insertions(+), 553 deletions(-)
 create mode 100644 advtrains_interlocking/aspect.lua
 delete mode 100644 advtrains_interlocking/signal_aspects.lua
 create mode 100644 advtrains_interlocking/spec/signal_group_spec.lua
 delete mode 100644 advtrains_interlocking/spec/type2_spec.lua

(limited to 'advtrains_signals_japan')

diff --git a/advtrains_interlocking/README.md b/advtrains_interlocking/README.md
index 636ad67..d4a2699 100644
--- a/advtrains_interlocking/README.md
+++ b/advtrains_interlocking/README.md
@@ -2,12 +2,6 @@
 
 The `advtrains_interlocking` mod provides various interlocking and signaling features for Advtrains.
 
-## Signal types
-There are two types of signals in Advtrains:
-
-* Type 1 (speed signals): These signals only give speed information.
-* Type 2 (route signals): These signals mainly provide route information, but sometimes also provide speed information.
-
 ## Signal aspect tables
 
 Signal aspects are represented using tables with the following (optional) fields:
@@ -16,15 +10,16 @@ Signal aspects are represented using tables with the following (optional) fields
 * `dst`: The distant signal aspect. It provides information on the permitted speed after passing the next signal.
 * `shunt`: Whether the train may proceed in shunt mode and, if the main aspect is danger, proceed in shunt mode.
 * `proceed_as_main`: Whether the train should exit shunt mode when proceeding.
-* `type2group`: The type 2 group of the signal.
-* `type2name`: The type 2 signal aspect name.
+* `group`: The name of the signal group.
+* `name`: The name of the signal aspect.
 
 The `main` and `dst` fields may be:
 
 * An positive number indicating the permitted speed,
 * The number 0, indicating that the train should expect to stop at the current signal (or, for the `dst` field, the next signal),
-* The number -1, indicating that the train can proceed (or, for the `dst` field, expect to proceed) at maximum speed, or
-* The constant `false` or `nil`, indicating no change to the speed restriction.
+* The number -1, indicating that the train can proceed (or, for the `dst` field, expect to proceed) at maximum speed,
+* The constant `false`, indicating no change to the speed restriction, or
+* The constant `nil`, indicating that the default value for the name aspect (if present) is used. If no valid signal aspect is named, or the signal aspect does not provide a default value, the value is assumed to be `false`.
 
 ### Node definitions
 
@@ -38,22 +33,19 @@ The node definition should contain an `advtrains` field.
 
 The `advtrains` field of the node definition should contain a `supported_aspects` table for signals with variable aspects.
 
-For type 1 signals, the `supported_aspects` table should contain the following fields:
+The `supported_aspects` table should contain the following fields:
 
 * `main`: A list of values supported for the main aspect.
 * `dst`: A list of values supported for the distant aspect.
 * `shunt`: The value for the `shunt` field of the signal aspect or `nil` if the value is variable.
 * `proceed_as_main`: The value for the `proceed_as_main` field of the signal aspect.
-
-For type 2 signals, the `supported_aspects` table should contain the following fields:
-
-* `type`: The numeric constant `2`.
-* `group`: The type 2 signal group.
+* `group`: The name of the signal group.
+* `name`: A list of supported (named) aspects.
 * `dst_shift`: The phase shift for distant/repeater signals. This field should not be set for main signals.
 
 The `advtrains` field of the node definition should contain a `get_aspect` function. This function is given the position of the signal and the node at the position. It should return the signal aspect table or, in the case of type 2 signals, the name of the signal aspect.
 
-For signals with variable aspects, a corresponding `set_aspect` function should also be defined. This function is given the position of the signal, the node at the position, and the new aspect (or, in the case of type 2 signals, the name of the new signal aspect). For type 1 signals, the new aspect is not guranteed to be supported by the signal itself.
+For signals with variable aspects, a corresponding `set_aspect` function should also be defined. This function is given the position of the signal, the node at the position, and the new aspect. The new aspect is not guaranteed to be supported by the signal itself.
 
 Signals should also have the following callbacks set:
 
@@ -63,23 +55,20 @@ Signals should also have the following callbacks set:
 
 Alternatively, custom callbacks should call the respective functions.
 
-## Type 2 signal groups
+## Signal groups
 
-Type 2 signals belong to signal gruops, which are registered using `advtrains.interlocking.aspects.register_type2`.
+Signals may belong to signal groups are registered using `advtrains.interlocking.aspect.register_group`.
 
 Signal group definitions include the following fields:
 
 * `name`: The internal name of the signal group. It is recommended to use the mod name as a prefix to avoid name collisions.
 * `label`: The description of the signal group.
-* `main`: A list of signal aspects, from the least restrictive (i.e. proceed) to the most restrictive (i.e. danger).
+* `aspects`: A table of signal aspects. Entries with string indices define the signal aspect with the name. Entries with numeric indices (starting from 1, counting upward) contain a list of corresponding aspect names (the first entry is preferred) and are mainly used for routing, where larger indices indicate that the signal with the aspect is closer to the signal with the "danger" (or similar) aspect.
 
 Each aspect in the signal group definition table should contain the following fields:
 
-* `name`: The internal name of the signal aspect.
 * `label`: The description of the signal aspect.
-* `main`, `shunt`, `proceed_as_main`: The fields corresponding to the ones in signal aspect tables.
-
-Type 2 signal aspects are then referred to with the aspect names within the group.
+* `main`, `shunt`, `proceed_as_main`: The default values for the aspect. Note that the `dst` field has no default value as it is automatically adjusted.
 
 ## Notes
 
@@ -89,8 +78,8 @@ It is allowed to provide other methods of setting the signal aspect. However:
 * Please call `advtrains.interlocking.signal_readjust_aspect` after the signal aspect has changed.
 
 ## Examples
-An example of type 1 signals can be found in `advtrains_signals_ks`, which provides a subset of German signals.
+An example of speed signals can be found in `advtrains_signals_ks`, which provides a subset of German signals.
 
-An example of type 2 signals can be found in `advtrains_signals_japan`, which provides a subset of Japanese signals.
+An example of route signals can be found in `advtrains_signals_japan`, which provides a subset of Japanese signals.
 
 The mods mentioned above are also used for demonstation purposes and can also be used for testing.
diff --git a/advtrains_interlocking/aspect.lua b/advtrains_interlocking/aspect.lua
new file mode 100644
index 0000000..1575fb1
--- /dev/null
+++ b/advtrains_interlocking/aspect.lua
@@ -0,0 +1,290 @@
+--- Signal aspect handling.
+-- @module advtrains.interlocking.aspect
+
+local registered_groups = {}
+
+local named_aspect_aspfields = {main = true, shunt = true, proceed_as_main = true}
+
+local signal_aspect = {}
+
+local signal_aspect_metatable = {
+	__eq = function(asp1, asp2)
+		for _, k in pairs {"main", "dst", "shunt", "proceed_as_main"} do
+			local v1, v2 = (asp1[k] or false), (asp2[k] or false)
+			if v1 ~= v2 then
+				return false
+			end
+		end
+		if asp1.group and asp1.group == asp2.group then
+			return asp1.name == asp2.name
+		end
+		return true
+	end,
+	__index = function(asp, field)
+		local method = signal_aspect[field]
+		if method then
+			return method
+		end
+		if not named_aspect_aspfields[field] then
+			return nil
+		end
+		local group = registered_groups[rawget(asp, "group")]
+		if not group then
+			return false
+		end
+		local aspdef = group.aspects[rawget(asp, "name")]
+		if not aspdef then
+			return false
+		end
+		return aspdef[field] or false
+	end,
+	__tostring = function(asp)
+		local st = {}
+		if asp.group and asp.name then
+			table.insert(st, ("%q in %q"):format(asp.name, asp.group))
+		end
+		if asp.main then
+			table.insert(st, ("current %d"):format(asp.main))
+		end
+		if asp.main ~= 0 then
+			if asp.dst then
+				table.insert(st, string.format("next %d", asp.dst))
+			end
+		end
+		if asp.main ~= 0 and asp.proceed_as_main then
+			table.insert(st, "proceed as main")
+		end
+		return ("[%s]"):format(table.concat(st, ", "))
+	end,
+}
+
+local function quicknew(t)
+	return setmetatable(t, signal_aspect_metatable)
+end
+
+--- Signal aspect class.
+-- @type signal_aspect
+
+--- Return a plain version of the signal aspect.
+-- @param[opt=false] raw Bypass metamethods when fetching signal aspects
+-- @return A plain copy of the signal aspect object.
+function signal_aspect:plain(raw)
+	local t = {}
+	for _, k in pairs {"main", "dst", "shunt", "proceed_as_main", "group", "name"} do
+		local v
+		if raw then
+			v = rawget(self, k)
+		else
+			v = self[k]
+		end
+		t[k] = v
+	end
+	return t
+end
+
+--- Create (or copy) a signal aspect object.
+-- Note that signal aspect objects can also be created by calling the `advtrains.interlocking.aspect` table.
+-- @return The newly created signal aspect object.
+function signal_aspect:new()
+	if type(self) ~= "table" then
+		return quicknew{}
+	end
+	local newasp = {}
+	for _, k in pairs {"main", "dst"} do
+		if type(self[k]) == "table" then
+			if self[k].free then
+				newasp[k] = self[k].speed
+			else
+				newasp[k] = 0
+			end
+		else
+			newasp[k] = self[k]
+		end
+	end
+	if type(self.shunt) == "table" then
+		newasp.shunt = self.shunt.free
+		newasp.proceed_as_main = self.shunt.proceed_as_main
+	else
+		newasp.shunt = self.shunt
+	end
+	for _, k in pairs {"group", "name"} do
+		newasp[k] = self[k]
+	end
+	return quicknew(newasp)
+end
+
+--- Modify the signal aspect in-place to fit in the specific signal group.
+-- @param group The signal group. The `nil` indicates a generic group.
+-- @return The (now modified) signal aspect itself.
+function signal_aspect:to_group(group)
+	local cg = self.group
+	local gdef = registered_groups[group]
+	if type(self.name) ~= "string" then
+		self.name = nil
+	end
+	if not gdef then
+		for k in pairs(named_aspect_aspfields) do
+			rawset(self, k, self[k])
+		end
+		self.group = nil
+		self.name = nil
+		return self
+	elseif cg == group and gdef.aspects[self.name] then
+		return self
+	end
+	local newidx = 1
+	if self.main == 0 then
+		newidx = #gdef.aspects
+	end
+	local cgdef = registered_groups[cg]
+	if cgdef then
+		local idx = (cgdef.aspects[self.name] or {}).index
+		if idx then
+			if idx >= #cgdef.aspects then
+				idx = #gdef.aspects
+			elseif idx >= #gdef.aspects then
+				idx = #gdef.aspects-1
+			end
+			newidx = idx
+		end
+	end
+	self.group = group
+	self.name = group.aspects[newidx][1]
+	return self
+end
+
+--- Modify the signal aspect in-place to indicate a specific distant aspect.
+-- @param dst The distant aspect
+-- @param[opt=1] shift The phase shift of the current signal.
+-- @return The (now modified) signal aspect itself.
+function signal_aspect:adjust_distant(dst, shift)
+	if (shift or -1) < 0 then
+		shift = 1
+	end
+	if not dst then
+		self.dst = nil
+		return self
+	end
+	if self.main ~= 0 then
+		self.dst = dst.main
+	else
+		self.dst = nil
+	end
+	local dgdef = registered_groups[dst.group]
+	if dgdef then
+		if self.group == dst.group and shift == 0 then
+			self.name = dst.name
+		else
+			local idx = (dgdef.aspects[dst.name] or {}).index
+			if idx then
+				idx = math.max(idx-shift, 1)
+				self.group = dst.group
+				self.name = dgdef.aspects[idx][1]
+			end
+		end
+	end
+	return self
+end
+
+--- Signal groups.
+-- @section signal_group
+
+--- Register a signal group.
+-- @function register_group
+-- @param def The definition table.
+local function register_group(def)
+	local t = {}
+	local name = def.name
+	if type(name) ~= "string" then
+		return error("Expected signal group name to be a string, got " .. type(name))
+	elseif registered_groups[name] then
+		return error(string.format("Attempt to redefine signal group %q, previously defined in %s", name, registered_groups[name].defined))
+	end
+	t.name = name
+
+	t.defined = debug.getinfo(2, "S").short_src or "[?]"
+
+	local label = def.label or name
+	if type(label) ~= "string" then
+		return error("Label is not a string")
+	end
+	t.label = label
+
+	local mainasps = {}
+	for idx, asp in pairs(def.aspects) do
+		local idxtp = type(idx)
+		if idxtp == "string" then
+			local t = {}
+			t.name = idx
+
+			local label = asp.label or idx
+			if type(label) ~= "string" then
+				return error("Aspect label is not a string")
+			end
+			t.label = label
+
+			for k in pairs(named_aspect_aspfields) do
+				t[k] = asp[k]
+			end
+
+			mainasps[idx] = t
+		end
+	end
+	if #def.aspects < 2 then
+		return error("Insufficient entries in signal aspect list")
+	end
+	for idx, asplist in ipairs(def.aspects) do
+		if type(asplist) ~= "table" then
+			asplist = {asplist}
+		else
+			asplist = table.copy(asplist)
+		end
+		if #asplist < 1 then
+			error("Invalid entry in signal aspect list")
+		end
+		for _, k in ipairs(asplist) do
+			if type(k) ~= "string" then
+				return error("Invalid signal aspect ID")
+			end
+			local asp = mainasps[k]
+			if not asp then
+				return error("Invalid signal aspect ID")
+			end
+			if asp.index ~= nil then
+				return error("Attempt to assign a signal aspect to multiple numeric indices")
+			end
+			asp.index = idx
+		end
+		mainasps[idx] = asplist
+	end
+	t.aspects = mainasps
+
+	registered_groups[name] = t
+end
+
+--- Get the definition of a signal group.
+-- @function get_group_definition
+-- @param name The name of the signal group.
+-- @return[1] The definition for the signal group (if present).
+-- @return[2] The nil constant (otherwise).
+local function get_group_definition(name)
+	local t = registered_groups[name]
+	if t then
+		return table.copy(t)
+	else
+		return nil
+	end
+end
+
+local lib = {
+	register_group = register_group,
+	get_group_definition = get_group_definition,
+}
+
+local libmt = {
+	__call = function(_, ...)
+		return signal_aspect.new(...)
+	end,
+}
+
+return setmetatable(lib, libmt)
diff --git a/advtrains_interlocking/distant.lua b/advtrains_interlocking/distant.lua
index 4175875..32ada82 100644
--- a/advtrains_interlocking/distant.lua
+++ b/advtrains_interlocking/distant.lua
@@ -6,7 +6,6 @@
 local db_distant = {}
 local db_distant_of = {}
 
-local A = advtrains.interlocking.aspects
 local pts = advtrains.encode_pos
 local stp = advtrains.decode_pos
 
diff --git a/advtrains_interlocking/init.lua b/advtrains_interlocking/init.lua
index 1a8ef07..4d959cc 100644
--- a/advtrains_interlocking/init.lua
+++ b/advtrains_interlocking/init.lua
@@ -12,7 +12,7 @@ end
 
 local modpath = minetest.get_modpath(minetest.get_current_modname()) .. DIR_DELIM
 
-advtrains.interlocking.aspects = dofile(modpath.."signal_aspects.lua")
+advtrains.interlocking.aspect = dofile(modpath.."aspect.lua")
 
 dofile(modpath.."database.lua")
 dofile(modpath.."distant.lua")
diff --git a/advtrains_interlocking/signal_api.lua b/advtrains_interlocking/signal_api.lua
index 1b4a21c..ce8854a 100644
--- a/advtrains_interlocking/signal_api.lua
+++ b/advtrains_interlocking/signal_api.lua
@@ -19,27 +19,7 @@ advtrains.interlocking.FULL_FREE = {
 	proceed_as_main = true,
 }
 
-local function convert_aspect_if_necessary(asp)
-	if type(asp.main) == "table" then
-		local newasp = {} 
-		if asp.main.free then
-			newasp.main = asp.main.speed
-		else
-			newasp.main = 0
-		end
-		if asp.dst and asp.dst.free then
-			newasp.dst = asp.dst.speed
-		else
-			newasp.dst = 0
-		end
-		newasp.proceed_as_main = asp.shunt.proceed_as_main
-		newasp.shunt = asp.shunt.free
-		-- Note: info table not transferred, it's not used right now
-		return newasp
-	end
-	return asp
-end
-advtrains.interlocking.signal_convert_aspect_if_necessary = convert_aspect_if_necessary
+advtrains.interlocking.signal_convert_aspect_if_necessary = advtrains.interlocking.aspect
 
 function advtrains.interlocking.update_signal_aspect(tcbs, skipdst)
 	if tcbs.signal then
@@ -79,7 +59,7 @@ function advtrains.interlocking.signal_rc_handler(pos, node, player, itemstack,
 	end
 	advtrains.interlocking.show_signal_form(pos, node, pname)
 end
-	
+
 function advtrains.interlocking.show_signal_form(pos, node, pname)
 	local sigd = advtrains.interlocking.db.get_sigd_for_signal(pos)
 	if sigd then
@@ -92,7 +72,7 @@ function advtrains.interlocking.show_signal_form(pos, node, pname)
 				advtrains.interlocking.signal_set_aspect(pos, aspect)
 			end
 			local isasp = advtrains.interlocking.signal_get_aspect(pos, node)
-			
+
 			advtrains.interlocking.show_signal_aspect_selector(
 				pname,
 				ndef.advtrains.supported_aspects,
@@ -123,7 +103,7 @@ local function ipmarker(ipos, connid)
 	local node_ok, conns, rhe = advtrains.get_rail_info_at(ipos, advtrains.all_tracktypes)
 	if not node_ok then return end
 	local yaw = advtrains.dir_to_angle(conns[connid].c)
-	
+
 	-- using tcbmarker here
 	local obj = minetest.add_entity(vector.add(ipos, {x=0, y=0.2, z=0}), "advtrains_interlocking:tcbmarker")
 	if not obj then return end
diff --git a/advtrains_interlocking/signal_aspect_accessors.lua b/advtrains_interlocking/signal_aspect_accessors.lua
index e419515..d91df31 100644
--- a/advtrains_interlocking/signal_aspect_accessors.lua
+++ b/advtrains_interlocking/signal_aspect_accessors.lua
@@ -1,33 +1,12 @@
 --- Signal aspect accessors
 -- @module advtrains.interlocking
 
-local A = advtrains.interlocking.aspects
+local A = advtrains.interlocking.aspect
 local D = advtrains.distant
 local I = advtrains.interlocking
 local N = advtrains.ndb
 local pts = advtrains.roundfloorpts
 
-local signal_aspect_metatable = {
-	__tostring = function(asp)
-		local st = {}
-		if asp.type2group and asp.type2name then
-			table.insert(st, string.format("%q in group %q", asp.type2name, asp.type2group))
-		end
-		if asp.main then
-			table.insert(st, string.format("current %d", asp.main))
-		end
-		if asp.main ~= 0 then
-			if asp.dst then
-				table.insert(st, string.format("next %d", asp.dst))
-			end
-			if asp.proceed_as_main then
-				table.insert(st, "proceed as main")
-			end
-		end
-		return string.format("[%s]", table.concat(st, ", "))
-	end,
-}
-
 local get_aspect
 
 local supposed_aspects = {}
@@ -37,9 +16,9 @@ local supposed_aspects = {}
 -- @param db The new database.
 function I.load_supposed_aspects(tbl)
 	if tbl then
-		supposed_aspects = tbl
-		for _, v in pairs(tbl) do
-			setmetatable(v, signal_aspect_metatable)
+		supposed_aspects = {}
+		for k, v in pairs(tbl) do
+			supposed_aspects[k] = A(v)
 		end
 	end
 end
@@ -48,7 +27,11 @@ end
 -- @function save_supposed_aspects
 -- @return The current database in use.
 function I.save_supposed_aspects()
-	return supposed_aspects
+	local t = {}
+	for k, v in pairs(supposed_aspects) do
+		t[k] = v:plain(true)
+	end
+	return t
 end
 
 --- Read the aspect of a signal strictly from cache.
@@ -72,7 +55,7 @@ end
 -- @return[2] An empty table (otherwise).
 local function get_ndef(pos)
 	local node = N.get_node(pos)
-	return minetest.registered_nodes[node.name] or {}
+	return (minetest.registered_nodes[node.name] or {}), node
 end
 
 --- Get the aspects supported by a signal.
@@ -94,43 +77,18 @@ end
 -- @return The adjusted signal aspect.
 -- @return The information to pass to the `advtrains.set_aspect` field in the node definitions.
 local function adjust_aspect(pos, asp)
-	asp = table.copy(I.signal_convert_aspect_if_necessary(asp))
-	setmetatable(asp, signal_aspect_metatable)
+	local asp = A(asp)
 
 	local mainpos = D.get_main(pos)
 	local nxtasp
 	if mainpos then
 		nxtasp = get_aspect(mainpos)
 	end
-	if asp.main ~= 0 and mainpos then
-		asp.dst = nxtasp.main
-	else
-		asp.dst = nil
-	end
-
 	local suppasp = get_supported_aspects(pos)
 	if not suppasp then
-		return asp, asp
-	end
-	local stype = suppasp.type
-	if stype == 2 then
-		local group = suppasp.group
-		local name
-		if suppasp.dst_shift and nxtasp then
-			asp.main = nil
-			name = A.type1_to_type2main(nxtasp, group, suppasp.dst_shift)
-		elseif asp.main ~= 0 and nxtasp and nxtasp.type2group == group and nxtasp.type2name then
-			name = A.get_type2_dst(group, nxtasp.type2name)
-		else
-			name = A.type1_to_type2main(asp, group)
-		end
-		asp.type2group = group
-		asp.type2name = name
-		return asp, name
+		return asp
 	end
-	asp.type2name = nil
-	asp.type2group = nil
-	return asp, asp
+	return asp:adjust_distant(nxtasp, suppasp.dst_shift):to_group(suppasp.group)
 end
 
 --- Get the aspect of a signal without accessing the cache.
@@ -140,13 +98,9 @@ end
 -- @return[1] The signal aspect adjusted using `adjust_aspect` (if present).
 -- @return[2] The nil constant (otherwise).
 local function get_real_aspect(pos)
-	local ndef = get_ndef(pos)
+	local ndef, node = get_ndef(pos)
 	if ndef.advtrains and ndef.advtrains.get_aspect then
 		local asp = ndef.advtrains.get_aspect(pos, node) or I.DANGER
-		local suppasp = get_supported_aspects(pos)
-		if suppasp and suppasp.type == 2 then
-			asp = A.type2_to_type1(suppasp, asp)
-		end
 		return adjust_aspect(pos, asp)
 	end
 	return nil
@@ -176,11 +130,11 @@ local function set_aspect(pos, asp, skipdst)
 	local ndef = minetest.registered_nodes[node.name]
 	if ndef and ndef.advtrains and ndef.advtrains.set_aspect then
 		local oldasp = I.signal_get_aspect(pos) or DANGER
-		local newasp, aspval = adjust_aspect(pos, asp)
+		local newasp = adjust_aspect(pos, asp)
 		set_supposed_aspect(pos, newasp)
-		ndef.advtrains.set_aspect(pos, node, aspval)
+		ndef.advtrains.set_aspect(pos, node, newasp)
 		I.signal_on_aspect_changed(pos)
-		local aspect_changed = A.not_equalp(oldasp, newasp)
+		local aspect_changed = oldasp ~= newasp
 		if (not skipdst) and aspect_changed then
 			D.update_main(pos)
 		end
diff --git a/advtrains_interlocking/signal_aspect_ui.lua b/advtrains_interlocking/signal_aspect_ui.lua
index 186d2fe..d36c6bc 100644
--- a/advtrains_interlocking/signal_aspect_ui.lua
+++ b/advtrains_interlocking/signal_aspect_ui.lua
@@ -1,7 +1,7 @@
 local F = advtrains.formspec
 local players_aspsel = {}
 
-local function describe_t1_main_aspect(spv)
+local function describe_main_aspect(spv)
 	if spv == 0 then
 		return attrans("Danger (halt)")
 	elseif spv == -1 then
@@ -13,7 +13,7 @@ local function describe_t1_main_aspect(spv)
 	end
 end
 
-local function describe_t1_shunt_aspect(shunt)
+local function describe_shunt_aspect(shunt)
 	if shunt then
 		return attrans("Shunting allowed")
 	else
@@ -21,7 +21,7 @@ local function describe_t1_shunt_aspect(shunt)
 	end
 end
 
-local function describe_t1_distant_aspect(spv)
+local function describe_distant_aspect(spv)
 	if spv == 0 then
 		return attrans("Expect to stop at the next signal")
 	elseif spv == -1 then
@@ -33,9 +33,9 @@ local function describe_t1_distant_aspect(spv)
 	end
 end
 
-advtrains.interlocking.describe_t1_main_aspect = describe_t1_main_aspect
-advtrains.interlocking.describe_t1_shunt_aspect = describe_t1_shunt_aspect
-advtrains.interlocking.describe_t1_distant_aspect = describe_t1_distant_aspect
+advtrains.interlocking.describe_main_aspect = describe_main_aspect
+advtrains.interlocking.describe_shunt_aspect = describe_shunt_aspect
+advtrains.interlocking.describe_distant_aspect = describe_distant_aspect
 
 local function dsel(p, q, x, y)
 	if p == nil then
@@ -51,19 +51,23 @@ local function dsel(p, q, x, y)
 	end
 end
 
-local function describe_supported_aspects_t1(suppasp, isasp)
+local function describe_supported_aspects(suppasp, isasp)
 	local t = {}
 
-	local entries = {}
-	local selid = 1
-	for idx, spv in ipairs(suppasp.main) do
-		if isasp and spv == (isasp.main or false) then
+	local entries = {attrans("Use default value")}
+	local selid = 0
+	local mainasps = suppasp.main
+	if type(mainasps) ~= "table" then
+		mainasps = {mainasps or false}
+	end
+	for idx, spv in ipairs(mainasps) do
+		if isasp and spv == rawget(isasp, "main") then
 			selid = idx
 		end
-		entries[idx] = describe_t1_main_aspect(spv)
+		entries[idx+1] = describe_main_aspect(spv)
 	end
 	t.main = entries
-	t.main_current = selid
+	t.main_current = selid+1
 	t.main_string = tostring(isasp.main)
 	if t.main == nil then
 		t.main_string = ""
@@ -83,21 +87,21 @@ local function describe_supported_aspects_t1(suppasp, isasp)
 
 	entries = {}
 	selid = 1
-	for idx, spv in ipairs(suppasp.dst) do
+	for idx, spv in ipairs(suppasp.dst or {}) do
 		if isasp and spv == (isasp.dst or false) then
 			selid = idx
 		end
-		entries[idx] = describe_t1_distant_aspect(spv)
+		entries[idx] = describe_distant_aspect(spv)
 	end
 	t.dst = entries
 	t.dst_current = selid
 	return t
 end
 
-advtrains.interlocking.describe_supported_aspects_t1 = describe_supported_aspects_t1
+advtrains.interlocking.describe_supported_aspects = describe_supported_aspects
 
-local function make_signal_aspect_selector_t1(suppasp, purpose, isasp)
-	local t = describe_supported_aspects_t1(suppasp, isasp)
+local function make_signal_aspect_selector(suppasp, purpose, isasp)
+	local t = describe_supported_aspects(suppasp, isasp)
 	local formmode = 1
 
 	local pos
@@ -142,55 +146,6 @@ local function make_signal_aspect_selector_t1(suppasp, purpose, isasp)
 	return table.concat(form)
 end
 
-local function make_signal_aspect_selector_t2(suppasp, purpose, isasp)
-	local def = advtrains.interlocking.aspects.get_type2_definition(suppasp.group)
-	if not def then
-		return nil
-	end
-	local formmode = 1
-
-	local pos
-	if type(purpose) == "table" then
-		formmode = 2
-		pos = purpose.pos
-	end
-	local form = {
-		"formspec_version[4]",
-		string.format("size[8,%f]", ({4.25, 10.25})[formmode]),
-		F.S_label(0.5, 0.5, "Select signal aspect")
-	}
-	if formmode == 1 then
-		form[#form+1] = F.label(0.5, 1, purpose)
-	else
-		form[#form+1] = F.S_label(0.5, 1, "Signal at @1", minetest.pos_to_string(pos))
-	end
-
-	local entries = {}
-	local selid = #def.main
-	if isasp then
-		if isasp.type2name ~= def.main[selid].name then
-			selid = 1
-		end
-	end
-	if selid > 1 then
-		selid = 2
-	end
-	local entries = {
-		def.main[1].label,
-		def.main[#def.main].label,
-	}
-	form[#form+1] = F.S_label(0.5, 1.5, "Signal group: @1", def.label)
-	form[#form+1] = F.dropdown(0.5, 2, 7, "asp_sel", entries, selid, true)
-	form[#form+1] = F.S_button_exit(0.5, 3, 7, "asp_save", "Save signal aspect")
-
-	if formmode == 2 then
-		form[#form+1] = advtrains.interlocking.make_ip_formspec_component(pos, 0.5, 4, 7)
-		form[#form+1] = advtrains.interlocking.make_dst_formspec_component(pos, 0.5, 5.5, 7, 4.25)
-	end
-
-	return table.concat(form)
-end
-
 function advtrains.interlocking.show_signal_aspect_selector(pname, p_suppasp, p_purpose, callback, isasp)
 	local suppasp = p_suppasp or {
 		main = {0, -1},
@@ -205,18 +160,7 @@ function advtrains.interlocking.show_signal_aspect_selector(pname, p_suppasp, p_
 		purpose = {pname = pname, pos = pos}
 	end
 
-	local form
-	if suppasp.type == 2 then
-		if suppasp.dst_shift then
-			if pos then
-				advtrains.interlocking.show_ip_form(pos, pname)
-			end
-			return
-		end
-		form = make_signal_aspect_selector_t2(suppasp, purpose, isasp)
-	else
-		form = make_signal_aspect_selector_t1(suppasp, purpose, isasp)
-	end
+	local form = make_signal_aspect_selector(suppasp, purpose, isasp)
 	if not form then
 		return
 	end
@@ -241,9 +185,9 @@ local function usebool(sup, val, free)
 	end
 end
 
-local function get_aspect_from_formspec_t1(suppasp, fields, psl)
+local function get_aspect_from_formspec(suppasp, fields, psl)
 	local maini = tonumber(fields.asp_mainsel)
-	local main = suppasp.main[maini]
+	local main = suppasp.main[(maini or 0)-1]
 	if not maini then
 		local mainval = fields.asp_mainval
 		if mainval == "-1" then
@@ -253,6 +197,8 @@ local function get_aspect_from_formspec_t1(suppasp, fields, psl)
 		else
 			main = nil
 		end
+	elseif maini <= 1 then
+		main = nil
 	end
 	local shunti = tonumber(fields.asp_shunt)
 	local shunt = suppasp.shunt
@@ -271,19 +217,6 @@ local function get_aspect_from_formspec_t1(suppasp, fields, psl)
 	}
 end
 
-local function get_aspect_from_formspec_t2(suppasp, fields, psl)
-	local sel = tonumber(fields.asp_sel)
-	local def = advtrains.interlocking.aspects.get_type2_definition(suppasp.group)
-	if not (sel and def) then
-		return
-	end
-	if sel ~= 1 then
-		sel = #def.main
-	end
-	local asp = advtrains.interlocking.aspects.type2_to_type1(suppasp, sel)
-	return asp
-end
-
 minetest.register_on_player_receive_fields(function(player, formname, fields)
 	local pname = player:get_player_name()
 	local psl = players_aspsel[pname]
@@ -292,11 +225,7 @@ minetest.register_on_player_receive_fields(function(player, formname, fields)
 			local suppasp = psl.suppasp
 			if fields.asp_save then
 				local asp
-				if suppasp.type == 2 then
-					asp = get_aspect_from_formspec_t2(suppasp, fields, psl)
-				else
-					asp = get_aspect_from_formspec_t1(suppasp, fields, psl)
-				end
+				asp = get_aspect_from_formspec(suppasp, fields, psl)
 				if asp then
 					psl.callback(pname, asp)
 				end
diff --git a/advtrains_interlocking/signal_aspects.lua b/advtrains_interlocking/signal_aspects.lua
deleted file mode 100644
index 14e04c7..0000000
--- a/advtrains_interlocking/signal_aspects.lua
+++ /dev/null
@@ -1,202 +0,0 @@
---- Signal aspect handling.
--- @module advtrains.interlocking.aspects
-
-local type2defs = {}
-
---- Register a type 2 signal group.
--- @function register_type2
--- @param def The definition table.
-local function register_type2(def)
-	local t = {type = 2}
-	local name = def.name
-	if type(name) ~= "string" then
-		return error("Name is not a string")
-	elseif type2defs[name] then
-		return error(string.format("Attempt to redefine type 2 signal aspect group %q, previously defined in %s", name, type2defs[name].defined))
-	end
-	t.name = name
-
-	t.defined = debug.getinfo(2, "S").short_src or "[?]"
-
-	local label = def.label or name
-	if type(label) ~= "string" then
-		return error("Label is not a string")
-	end
-	t.label = label
-
-	local mainasps = {}
-	for idx, asp in ipairs(def.main) do
-		local t = {}
-		local name = asp.name
-		if type(name) ~= "string" then
-			return error("Aspect name is not a string")
-		end
-		t.name = name
-
-		local label = asp.label or name
-		if type(label) ~= "string" then
-			return error("Aspect label is not a string")
-		end
-		t.label = label
-
-		t.main = asp.main
-		t.shunt = asp.shunt
-		t.proceed_as_main = asp.proceed_as_main
-		mainasps[idx] = t
-		mainasps[name] = idx
-	end
-	t.main = mainasps
-
-	type2defs[name] = t
-end
-
---- Get the definition of a type 2 signal group.
--- @function get_type2_definition
--- @param name The name of the signal group.
--- @return[1] The definition for the signal group (if present).
--- @return[2] The nil constant (otherwise).
-local function get_type2_definition(name)
-	local t = type2defs[name]
-	if t then
-		return table.copy(t)
-	else
-		return nil
-	end
-end
-
---- Get the name of the distant aspect before the current aspect.
--- @function get_type2_dst
--- @param group The name of the group.
--- @param name The name of the current aspect.
--- @return[1] The name of the distant aspect (if present).
--- @return[2] The nil constant (otherwise).
-local function get_type2_dst(group, name)
-	local def = type2defs[group]
-	if not def then
-		return nil
-	end
-	local aspidx = name
-	if type(name) ~= "number" then
-		aspidx = def.main[name] or 1
-	end
-	return def.main[math.max(1, aspidx-1)].name
-end
-
---- Convert a type 2 signal aspect to a type 1 signal aspect.
--- @function type2_to_type1
--- @param suppasp The table of supported aspects for the signal.
--- @param asp The name of the signal aspect.
--- @return[1] The type 1 signal aspect table (if present).
--- @return[2] The nil constant (otherwise).
-local function type2_to_type1(suppasp, asp)
-	local name = suppasp.group
-	local shift = suppasp.dst_shift
-	local def = type2defs[name]
-	if not def then
-		return nil
-	end
-	local aspidx
-	if type(asp) == "number" then
-		aspidx = asp
-	else
-		aspidx = def.main[asp] or 2
-	end
-	local realidx = math.min(#def.main, aspidx+(shift or 0))
-	local asptbl = def.main[realidx]
-	if not asptbl then
-		return nil
-	end
-	if type(asp) == "number" then
-		asp = asptbl.name
-	end
-	local main, shunt, dst
-	if shift then
-		dst = asptbl.main
-	else
-		main = asptbl.main
-		shunt = asptbl.shunt
-		dst = def.main[math.min(#def.main, aspidx+1)].main
-	end
-	if main == 0 then
-		dst = nil
-	end
-
-	local t = {
-		main = main,
-		shunt = shunt,
-		proceed_as_main = asptbl.proceed_as_main,
-		type2name = asptbl.name,
-		type2group = name,
-		dst = dst,
-	}
-	if aspidx > 1 and aspidx < #asptbl then
-		t.dst = asptbl[aspidx+1].main
-	end
-	return t
-end
-
---- Convert a type 1 signal aspect table to a type 2 signal aspect.
--- @function type1_to_type2main
--- @param asp The type 1 signal aspect table
--- @param group The signal aspect group
--- @param[opt=0] shift The shift for the signal aspect.
--- @return[1] The name of the signal aspect (if present).
--- @return[2] The nil constant (otherwise).
-local function type1_to_type2main(asp, group, shift)
-	local def = type2defs[group]
-	if not def then
-		return nil
-	end
-	local t_main = def.main
-	local idx
-	if group == asp.type2group and t_main[asp.type2name] then
-		idx = t_main[asp.type2name]
-	elseif not asp.main or asp.main == -1 then
-		idx = 1
-	elseif asp.main == 0 then
-		idx = #t_main
-	else
-		idx = #t_main-1
-	end
-	return t_main[math.max(1, idx-(shift or 0))].name
-end
-
---- Compare two type 1 signal aspect tables.
--- @function equalp
--- @param asp1 The first signal aspect table.
--- @param asp2 The second signal aspect table.
--- @return Whether the two signal aspect tables give the same (type 1 aspect) information.
-local function equalp(asp1, asp2)
-	if asp1 == asp2 then -- same reference
-		return true
-	else
-		for _, k in pairs {"main", "shunt", "dst"} do
-			if asp1[k] ~= asp2[k] then
-				return false
-			end
-		end
-	end
-	if asp1.type2group and asp1.type2group == asp2.type2group then
-		return asp1.type2name == asp2.type2name
-	end
-	return true
-end
-
---- Compare two signal aspect tables.
--- @function not_equalp
--- @param asp1 The first signal aspect table.
--- @param asp2 The second signal aspect table.
--- @return The negation of `equalp``(asp1, asp2)`.
-local function not_equalp(asp1, asp2)
-	return not equalp(asp1, asp2)
-end
-
-return {
-	register_type2 = register_type2,
-	get_type2_definition = get_type2_definition,
-	get_type2_dst = get_type2_dst,
-	type2_to_type1 = type2_to_type1,
-	type1_to_type2main = type1_to_type2main,
-	equalp = equalp,
-	not_equalp = not_equalp,
-}
diff --git a/advtrains_interlocking/spec/basic_signalling_spec.lua b/advtrains_interlocking/spec/basic_signalling_spec.lua
index cce0f15..a4e1e3a 100644
--- a/advtrains_interlocking/spec/basic_signalling_spec.lua
+++ b/advtrains_interlocking/spec/basic_signalling_spec.lua
@@ -8,7 +8,7 @@ mineunit("core")
 
 _G.advtrains = {
 	interlocking = {
-		aspects = fixture("../../signal_aspects"),
+		aspect = fixture("../../aspect"),
 	},
 	ndb = {
 		get_node = minetest.get_node,
@@ -31,12 +31,16 @@ minetest.register_node("advtrains_interlocking:signal_sign", {
 
 local D = advtrains.distant
 local I = advtrains.interlocking
+local A = I.aspect
 
 local stub_aspect_t1 = {
 	free = {main = -1},
 	slow = {main = 6},
 	danger = {main = 0, shunt = false},
 }
+for k, v in pairs(stub_aspect_t1) do
+	stub_aspect_t1[k] = A(v)
+end
 local stub_pos_t1 = {}
 for i = 1, 4 do
 	stub_pos_t1[i] = {x = 1, y = 0, z = i}
@@ -55,14 +59,14 @@ describe("API for supposed signal aspects", function()
 		I.load_supposed_aspects(tbl)
 		assert.same(tbl, I.save_supposed_aspects())
 	end)
-	it("should set and get type 1 signals properly", function ()
+	it("should set and get signals properly", function ()
 		local pos = stub_pos_t1[2]
 		local asp = stub_aspect_t1.slow
-		local newasp = { main = math.random(1,5) }
-		assert.same(asp, I.signal_get_aspect(pos))
+		local newasp = A{ main = math.random(1,5) }
+		assert.equal(asp, I.signal_get_aspect(pos))
 		I.signal_set_aspect(pos, newasp)
-		assert.same(newasp, I.signal_get_aspect(pos))
-		assert.same(asp, I.signal_get_real_aspect(pos))
+		assert.equal(newasp, I.signal_get_aspect(pos))
+		assert.equal(asp, I.signal_get_real_aspect(pos))
 		I.signal_set_aspect(pos, asp)
 	end)
 end)
@@ -72,9 +76,9 @@ describe("Distant signaling", function()
 		for i = 1, 2 do
 			D.assign(stub_pos_t1[i], stub_pos_t1[i+1])
 		end
-		assert.same(stub_aspect_t1.danger, I.signal_get_aspect(stub_pos_t1[1]))
-		assert.same({main = 6, dst = 0}, I.signal_get_aspect(stub_pos_t1[2]))
-		assert.same({main = -1, dst = 6}, I.signal_get_aspect(stub_pos_t1[3]))
+		assert.equal(stub_aspect_t1.danger, I.signal_get_aspect(stub_pos_t1[1]))
+		assert.equal(A{main = 6, dst = 0}, I.signal_get_aspect(stub_pos_t1[2]))
+		assert.equal(A{main = -1, dst = 6}, I.signal_get_aspect(stub_pos_t1[3]))
 	end)
 	it("should report assignments properly", function()
 		assert.same({stub_pos_t1[1], "manual"}, {D.get_main(stub_pos_t1[2])})
@@ -82,8 +86,8 @@ describe("Distant signaling", function()
 	end)
 	it("should update distant aspects automatically", function()
 		I.signal_set_aspect(stub_pos_t1[2], {main = 2, dst = -1})
-		assert.same({main = 2, dst = 0}, I.signal_get_aspect(stub_pos_t1[2]))
-		assert.same({main = -1, dst = 2}, I.signal_get_aspect(stub_pos_t1[3]))
+		assert.equal(A{main = 2, dst = 0}, I.signal_get_aspect(stub_pos_t1[2]))
+		assert.equal(A{main = -1, dst = 2}, I.signal_get_aspect(stub_pos_t1[3]))
 	end)
 	it("should unassign signals when one is removed", function()
 		world.set_node(stub_pos_t1[2], "air")
diff --git a/advtrains_interlocking/spec/signal_group_spec.lua b/advtrains_interlocking/spec/signal_group_spec.lua
new file mode 100644
index 0000000..bc9d007
--- /dev/null
+++ b/advtrains_interlocking/spec/signal_group_spec.lua
@@ -0,0 +1,95 @@
+require "mineunit"
+mineunit("core")
+
+_G.advtrains = {
+	interlocking = {
+		aspect = sourcefile("aspect"),
+	},
+	ndb = {
+		get_node = minetest.get_node,
+		swap_node = minetest.swap_node,
+	}
+}
+
+fixture("advtrains_helpers")
+sourcefile("database")
+sourcefile("signal_api")
+sourcefile("distant")
+sourcefile("signal_aspect_accessors")
+
+local A = advtrains.interlocking.aspect
+local D = advtrains.distant
+local I = advtrains.interlocking
+local N = advtrains.ndb
+
+local groupdef = {
+	name = "foo",
+	aspects = {
+		proceed = {main = -1},
+		caution = {},
+		danger = {main = 0},
+		"proceed",
+		{"caution"},
+		"danger",
+	},
+}
+
+for k, v in pairs(groupdef.aspects) do
+	minetest.register_node("advtrains_interlocking:" .. k, {
+		advtrains = {
+			supported_aspects = {
+				group = "foo",
+			},
+			get_aspect = function() return A{group = "foo", name = k} end,
+			set_aspect = function(pos, _, name)
+				N.swap_node(pos, {name = "advtrains_interlocking:" .. name})
+			end,
+		}
+	})
+end
+
+local origin = vector.new(0, 0, 0)
+local dstpos = vector.new(0, 0, 1)
+
+world.layout {
+	{origin, "advtrains_interlocking:danger"},
+	{dstpos, "advtrains_interlocking:proceed"},
+}
+
+describe("signal group registration", function()
+	it("should work", function()
+		A.register_group(groupdef)
+		assert(A.get_group_definition("foo"))
+	end)
+	it("should only be allowed once for the same group", function()
+		assert.has.errors(function() A.register_group(type2def) end)
+	end)
+	it("should handle nonexistant groups", function()
+		assert.is_nil(A.get_group_definition("something_else"))
+	end)
+	it("should reject invalid definitions", function()
+		assert.has.errors(function() A.register_group({}) end)
+		assert.has.errors(function() A.register_group({name="",label={}}) end)
+		assert.has.errors(function() A.register_group({name="",aspects={}}) end)
+	end)
+end)
+
+describe("signal aspect", function()
+	it("should handle empty fields properly", function()
+		assert.equal(A{main = 0}, A{group="foo", name="danger"}:to_group())
+	end)
+	it("should be converted properly", function()
+		assert.equal(A{main = 0}, A{group="foo", name="danger"})
+		assert.equal(A{}, A{group="foo", name="caution"})
+		assert.equal(A{main = -1}, A{group="foo", name="proceed"})
+	end)
+end)
+
+describe("signals in groups", function()
+	it("should support distant signaling", function()
+		assert.equal("caution", A():adjust_distant(A{group="foo",name="danger"}).name)
+		assert.equal("proceed", A():adjust_distant(A{group="foo",name="caution"}).name)
+		assert.equal("proceed", A():adjust_distant(A{group="foo",name="proceed"}).name)
+		assert.equal("danger", A{group="foo",name="danger"}:adjust_distant{}.name)
+	end)
+end)
diff --git a/advtrains_interlocking/spec/type2_spec.lua b/advtrains_interlocking/spec/type2_spec.lua
deleted file mode 100644
index ac23574..0000000
--- a/advtrains_interlocking/spec/type2_spec.lua
+++ /dev/null
@@ -1,117 +0,0 @@
-require "mineunit"
-mineunit("core")
-
-_G.advtrains = {
-	interlocking = {
-		aspects = sourcefile("signal_aspects"),
-	},
-	ndb = {
-		get_node = minetest.get_node,
-		swap_node = minetest.swap_node,
-	}
-}
-
-fixture("advtrains_helpers")
-sourcefile("database")
-sourcefile("signal_api")
-sourcefile("distant")
-sourcefile("signal_aspect_accessors")
-
-local A = advtrains.interlocking.aspects
-local D = advtrains.distant
-local I = advtrains.interlocking
-local N = advtrains.ndb
-
-local type2def = {
-	name = "foo",
-	main = {
-		{name = "proceed", main = -1},
-		{name = "caution"},
-		{name = "danger", main = 0},
-	},
-}
-
-for _, v in pairs(type2def.main) do
-	minetest.register_node("advtrains_interlocking:" .. v.name, {
-		advtrains = {
-			supported_aspects = {
-				type = 2,
-				group = "foo",
-			},
-			get_aspect = function() return v.name end,
-			set_aspect = function(pos, _, name)
-				N.swap_node(pos, {name = "advtrains_interlocking:" .. name})
-			end,
-		}
-	})
-end
-
-local function asp(group, name, dst)
-	return A.type2_to_type1({group = group, dst_shift = shift}, name)
-end
-
-local origin = vector.new(0, 0, 0)
-local dstpos = vector.new(0, 0, 1)
-
-world.layout {
-	{origin, "advtrains_interlocking:danger"},
-	{dstpos, "advtrains_interlocking:proceed"},
-}
-
-describe("type 2 signal group registration", function()
-	it("should work", function()
-		A.register_type2(type2def)
-		assert(A.get_type2_definition("foo"))
-	end)
-	it("should only be allowed once for the same group", function()
-		assert.has.errors(function() A.register_type2(type2def) end)
-	end)
-	it("should handle nonexistant groups", function()
-		assert.is_nil(A.get_type2_definition("something_else"))
-	end)
-	it("should reject invalid definitions", function()
-		assert.has.errors(function() A.register_type2({}) end)
-		assert.has.errors(function() A.register_type2({name="",label={}}) end)
-		assert.has.errors(function() A.register_type2({name="",main={{name={}}}}) end)
-		assert.has.errors(function() A.register_type2({name="",main={{name="",label={}}}}) end)
-	end)
-end)
-
-describe("signal aspect conversion", function()
-	it("should work for converting from type 1 to type 2", function()
-		assert.equal("danger", A.type1_to_type2main({main = 0}, "foo"))
-		assert.equal("caution", A.type1_to_type2main({main = 6}, "foo"))
-		assert.equal("proceed", A.type1_to_type2main({}, "foo"))
-	end)
-	it("should reject invalid type 2 signal information", function()
-		assert.is_nil(A.type1_to_type2main({}, "?"))
-		assert.is_nil(A.type2_to_type1({}, "x"))
-		assert.same(asp("foo","caution"), asp("foo", "x"))
-	end)
-	it("should accept integer indices for type 2 signal aspects", function()
-		assert.same(asp("foo", "caution"), asp("foo", 2))
-		assert.same(asp("foo", "danger"), asp("foo", 10))
-		assert.same(asp("foo", "proceed"), asp("foo", 1))
-		assert.is_nil(asp("foo", -0.5))
-	end)
-end)
-
-describe("type 2 signals", function()
-	it("should support distant signaling", function()
-		assert.equal("caution", A.get_type2_dst("foo", 3))
-		assert.equal("proceed", A.get_type2_dst("foo", "caution"))
-		assert.equal("proceed", A.get_type2_dst("foo", "proceed"))
-	end)
-	it("should work with accessors", function()
-		assert.same(asp("foo","danger"), I.signal_get_aspect(origin))
-		local newasp = {type2group = "foo", type2name = "proceed", main = 6}
-		I.signal_set_aspect(origin, newasp)
-		assert.same(newasp, I.signal_get_aspect(origin))
-	end)
-	it("should work with distant signaling", function()
-		assert.same(asp("foo","proceed"), I.signal_get_aspect(dstpos))
-		local dstasp = {type2group = "foo", type2name = "proceed", dst = 6, main = -1}
-		D.assign(origin, dstpos)
-		assert.same(dstasp, I.signal_get_aspect(dstpos))
-	end)
-end)
diff --git a/advtrains_signals_japan/init.lua b/advtrains_signals_japan/init.lua
index fe74259..7d8dc1e 100644
--- a/advtrains_signals_japan/init.lua
+++ b/advtrains_signals_japan/init.lua
@@ -291,10 +291,10 @@ local aspnames = {
 }
 local function process_signal(name, sigdata, isrpt)
 	local typename = "advtrains_signals_japan:" .. name
-	local type2def = {}
-	type2def.name = typename
-	type2def.main = {}
-	type2def.label = S(string.format("Japanese signal (type %s)", string.upper(name)))
+	local groupdef = {}
+	groupdef.name = typename
+	groupdef.aspects = {}
+	groupdef.label = S(string.format("Japanese signal (type %s)", string.upper(name)))
 	local def = {}
 	local tx = {}
 	def.typename = typename
@@ -322,7 +322,8 @@ local function process_signal(name, sigdata, isrpt)
 			tt[#tt+1] = string.format("0,%d=(advtrains_hud_bg.png\\^[colorize\\:%s)", lightcount-1, color)
 		end
 		tx[aspname] = table.concat(tt, ":")
-		type2def.main[idx] = {name = asp.name, label = S(aspnames[asp.name]), main = asp.main, proceed_as_main = true}
+		groupdef.aspects[idx] = {asp.name}
+		groupdef.aspects[asp.name] = {label = S(aspnames[asp.name]), main = asp.main, proceed_as_main = true}
 	end
 	local invimg = {
 		string.format("[combine:%dx%d", lightcount*4+1, lightcount*4+1),
@@ -337,7 +338,7 @@ local function process_signal(name, sigdata, isrpt)
 	end
 	def.inventory_image = table.concat(invimg, ":")
 	if not isrpt then
-		advtrains.interlocking.aspects.register_type2(type2def)
+		advtrains.interlocking.aspect.register_group(groupdef)
 	end
 	return def
 end
@@ -400,15 +401,14 @@ for _, rtab in ipairs {
 				drop = "advtrains_signals_japan:"..sigtype.."_danger_0",
 				advtrains = {
 					supported_aspects = {
-						type = 2,
 						group = siginfo.typename,
 						dst_shift = siginfo.isdst and 0,
 					},
 					get_aspect = function()
-						return asp
+						return {group = siginfo.typename, name = asp}
 					end,
 					set_aspect = function(pos, node, asp)
-						advtrains.ndb.swap_node(pos, {name = "advtrains_signals_japan:"..sigtype.."_"..asp.."_"..rot, param2 = node.param2})
+						advtrains.ndb.swap_node(pos, {name = "advtrains_signals_japan:"..sigtype.."_"..(asp.name).."_"..rot, param2 = node.param2})
 					end,
 				},
 				on_rightclick = advtrains.interlocking.signal_rc_handler,
-- 
cgit v1.2.3


From 2afe8027986b2a8172d2cb47236e53e8f24b30f5 Mon Sep 17 00:00:00 2001
From: "Y. Wang" <yw05@forksworld.de>
Date: Sun, 26 Mar 2023 16:25:45 +0200
Subject: Allow selecting named aspect

---
 advtrains_interlocking/aspect.lua           |  3 +-
 advtrains_interlocking/signal_aspect_ui.lua | 82 ++++++++++++++++++-----------
 advtrains_signals_japan/init.lua            | 58 +++++++++++++-------
 3 files changed, 91 insertions(+), 52 deletions(-)

(limited to 'advtrains_signals_japan')

diff --git a/advtrains_interlocking/aspect.lua b/advtrains_interlocking/aspect.lua
index 1575fb1..6d6cb93 100644
--- a/advtrains_interlocking/aspect.lua
+++ b/advtrains_interlocking/aspect.lua
@@ -149,7 +149,7 @@ function signal_aspect:to_group(group)
 		end
 	end
 	self.group = group
-	self.name = group.aspects[newidx][1]
+	self.name = gdef.aspects[newidx][1]
 	return self
 end
 
@@ -169,6 +169,7 @@ function signal_aspect:adjust_distant(dst, shift)
 		self.dst = dst.main
 	else
 		self.dst = nil
+		return self
 	end
 	local dgdef = registered_groups[dst.group]
 	if dgdef then
diff --git a/advtrains_interlocking/signal_aspect_ui.lua b/advtrains_interlocking/signal_aspect_ui.lua
index d36c6bc..a81b7fe 100644
--- a/advtrains_interlocking/signal_aspect_ui.lua
+++ b/advtrains_interlocking/signal_aspect_ui.lua
@@ -58,7 +58,7 @@ local function describe_supported_aspects(suppasp, isasp)
 	local selid = 0
 	local mainasps = suppasp.main
 	if type(mainasps) ~= "table" then
-		mainasps = {mainasps or false}
+		mainasps = {mainasps}
 	end
 	for idx, spv in ipairs(mainasps) do
 		if isasp and spv == rawget(isasp, "main") then
@@ -85,16 +85,24 @@ local function describe_supported_aspects(suppasp, isasp)
 	end
 	t.shunt_const = suppasp.shunt ~= nil
 
-	entries = {}
-	selid = 1
-	for idx, spv in ipairs(suppasp.dst or {}) do
-		if isasp and spv == (isasp.dst or false) then
-			selid = idx
+	if suppasp.group then
+		local gdef = advtrains.interlocking.aspect.get_group_definition(suppasp.group)
+		if gdef then
+			t.group = suppasp.group
+			t.groupdef = gdef
+			local entries = {}
+			local selid = 1
+			for idx, name in ipairs(suppasp.name or {}) do
+				entries[idx] = gdef.aspects[name].label
+				if suppasp.group == isasp.group and name == isasp.name then
+					selid = idx
+				end
+			end
+			t.name = entries
+			t.name_current = selid
 		end
-		entries[idx] = describe_distant_aspect(spv)
 	end
-	t.dst = entries
-	t.dst_current = selid
+
 	return t
 end
 
@@ -112,35 +120,35 @@ local function make_signal_aspect_selector(suppasp, purpose, isasp)
 
 	local form = {
 		"formspec_version[4]",
-		string.format("size[8,%f]", ({5.75, 9.25})[formmode]),
+		string.format("size[8,%f]", ({5.75, 10.75})[formmode]),
 		F.S_label(0.5, 0.5, "Select signal aspect"),
 	}
+	local h0 = ({0, 1.5})[formmode]
+	form[#form+1] = F.S_label(0.5, 1.5+h0, "Main aspect")
+	form[#form+1] = F.S_label(0.5, 3+h0, "Shunt aspect")
+	form[#form+1] = F.S_button_exit(0.5, 4.5+h0, 7, "asp_save", "Save signal aspect")
 	if formmode == 1 then
 		form[#form+1] = F.label(0.5, 1, purpose)
-	else
-		form[#form+1] = F.S_label(0.5, 1, "Signal at @1", minetest.pos_to_string(pos))
-	end
-
-	form[#form+1] = F.S_label(0.5, 1.5, "Main aspect")
-	if formmode == 1 then
 		form[#form+1] = F.field(0.5, 2, 7, "asp_mainval", "", t.main_string)
-	else
-		form[#form+1] = F.dropdown(0.5, 2, 7, "asp_mainsel", t.main, t.main_current, true)
+	elseif formmode == 2 then
+		if t.group then
+			form[#form+1] = F.S_label(0.5, 1.5, "Signal aspect group: @1", t.groupdef.label)
+			form[#form+1] = F.dropdown(0.5, 2, 7, "asp_namesel", t.name, t.name_current, true)
+		else
+			form[#form+1] = F.S_label(0.5, 1.5, "This signal does not belong to a signal aspect group.")
+			form[#form+1] = F.S_label(0.5, 2, "You can not use a predefined signal aspect.")
+		end
+		form[#form+1] = F.S_label(0.5, 1, "Signal at @1", minetest.pos_to_string(pos))
+		form[#form+1] = F.dropdown(0.5, 3.5, 7, "asp_mainsel", t.main, t.main_current, true)
+		form[#form+1] = advtrains.interlocking.make_ip_formspec_component(pos, 0.5, 7, 7)
+		form[#form+1] = advtrains.interlocking.make_short_dst_formspec_component(pos, 0.5, 8.5, 7)
 	end
 
-	form[#form+1] = F.S_label(0.5, 3, "Shunt aspect")
 	if formmode == 2 and t.shunt_const then
-		form[#form+1] = F.label(0.5, 3.5, t.shunt[t.shunt_current])
-		form[#form+1] = F.S_label(0.5, 4, "The shunt aspect cannot be changed.")
+		form[#form+1] = F.label(0.5, 3.5+h0, t.shunt[t.shunt_current])
+		form[#form+1] = F.S_label(0.5, 4+h0, "The shunt aspect cannot be changed.")
 	else
-		form[#form+1] = F.dropdown(0.5, 3.5, 7, "asp_shunt", t.shunt, t.shunt_current, true)
-	end
-
-	form[#form+1] = F.S_button_exit(0.5, 4.5, 7, "asp_save", "Save signal aspect")
-
-	if formmode == 2 then
-		form[#form+1] = advtrains.interlocking.make_ip_formspec_component(pos, 0.5, 5.5, 7)
-		form[#form+1] = advtrains.interlocking.make_short_dst_formspec_component(pos, 0.5, 7, 7)
+		form[#form+1] = F.dropdown(0.5, 3.5+h0, 7, "asp_shunt", t.shunt, t.shunt_current, true)
 	end
 
 	return table.concat(form)
@@ -186,12 +194,22 @@ local function usebool(sup, val, free)
 end
 
 local function get_aspect_from_formspec(suppasp, fields, psl)
+	local namei, group, name = tonumber(fields.asp_namesel), suppasp.group, nil
+	local gdef = advtrains.interlocking.aspect.get_group_definition(group)
+	if gdef then
+		local names = suppasp.name or {}
+		name = names[namei] or names[names]
+	else
+		group = nil
+	end
 	local maini = tonumber(fields.asp_mainsel)
-	local main = suppasp.main[(maini or 0)-1]
+	local main = (suppasp.main or {})[(maini or 0)-1]
 	if not maini then
 		local mainval = fields.asp_mainval
 		if mainval == "-1" then
 			main = -1
+		elseif mainval == "x" then
+			main = false
 		elseif string.match(mainval, "^%d+$") then
 			main = tonumber(mainval)
 		else
@@ -209,11 +227,13 @@ local function get_aspect_from_formspec(suppasp, fields, psl)
 	if proceed_as_main == nil then
 		proceed_as_main = shunti == 3
 	end
-	return {
+	return advtrains.interlocking.aspect {
 		main = main,
 		shunt = shunt,
 		proceed_as_main = proceed_as_main,
 		info = {},
+		name = name,
+		group = group,
 	}
 end
 
diff --git a/advtrains_signals_japan/init.lua b/advtrains_signals_japan/init.lua
index 7d8dc1e..84373a9 100644
--- a/advtrains_signals_japan/init.lua
+++ b/advtrains_signals_japan/init.lua
@@ -275,6 +275,34 @@ minetest.register_node("advtrains_signals_japan:pole_0", {
 	drop = "advtrains_signals_japan:pole_0",
 })
 
+advtrains.interlocking.aspect.register_group {
+	name = "advtrains_signals_japan:5a",
+	label = S("Japanese signal"),
+	aspects = {
+		danger = {
+			label = S"Danger (halt)",
+			main = 0,
+		},
+		restrictedspeed = {
+			label = S"Restricted speed",
+		},
+		caution = {
+			label = S"Caution",
+		},
+		reducedspeed = {
+			label = S"Reduced speed",
+		},
+		clear = {
+			label = S"Clear (proceed)",
+		},
+		"clear",
+		"reducedspeed",
+		"caution",
+		"restrictedspeed",
+		"danger",
+	}
+}
+
 local sigdefs = {}
 local lightcolors = {
 	red = "red",
@@ -282,22 +310,9 @@ local lightcolors = {
 	yellow = "orange",
 	distant = "purple",
 }
-local aspnames = {
-	danger = "Danger (halt)",
-	restrictedspeed = "Restricted speed",
-	caution = "Caution",
-	reducedspeed = "Reduced speed",
-	clear = "Clear (proceed)",
-}
 local function process_signal(name, sigdata, isrpt)
-	local typename = "advtrains_signals_japan:" .. name
-	local groupdef = {}
-	groupdef.name = typename
-	groupdef.aspects = {}
-	groupdef.label = S(string.format("Japanese signal (type %s)", string.upper(name)))
 	local def = {}
 	local tx = {}
-	def.typename = typename
 	def.textures = tx
 	def.desc = sigdata.desc
 	def.isdst = isrpt
@@ -307,6 +322,7 @@ local function process_signal(name, sigdata, isrpt)
 		lightcount = lightcount+1
 	end
 	def.lightcount = lightcount
+	def.suppasp_names = {}
 	for idx, asp in ipairs(sigdata.aspects) do
 		local aspname = asp.name
 		local tt = {
@@ -322,8 +338,7 @@ local function process_signal(name, sigdata, isrpt)
 			tt[#tt+1] = string.format("0,%d=(advtrains_hud_bg.png\\^[colorize\\:%s)", lightcount-1, color)
 		end
 		tx[aspname] = table.concat(tt, ":")
-		groupdef.aspects[idx] = {asp.name}
-		groupdef.aspects[asp.name] = {label = S(aspnames[asp.name]), main = asp.main, proceed_as_main = true}
+		def.suppasp_names[idx] = aspname
 	end
 	local invimg = {
 		string.format("[combine:%dx%d", lightcount*4+1, lightcount*4+1),
@@ -337,9 +352,6 @@ local function process_signal(name, sigdata, isrpt)
 		invimg[lightcount+2] = string.format("%d,%d=(advtrains_hud_bg.png\\^[resize\\:3x3\\^[colorize\\:%s)", 2*lightcount-1, 4*lightcount-3, lightcolors.distant)
 	end
 	def.inventory_image = table.concat(invimg, ":")
-	if not isrpt then
-		advtrains.interlocking.aspect.register_group(groupdef)
-	end
 	return def
 end
 for sigtype, sigdata in pairs {
@@ -401,11 +413,17 @@ for _, rtab in ipairs {
 				drop = "advtrains_signals_japan:"..sigtype.."_danger_0",
 				advtrains = {
 					supported_aspects = {
-						group = siginfo.typename,
+						group = "advtrains_signals_japan:5a",
+						name = siginfo.suppasp_names,
 						dst_shift = siginfo.isdst and 0,
+						main = (not siginfo.isdst) and {} or false
 					},
 					get_aspect = function()
-						return {group = siginfo.typename, name = asp}
+						local main
+						if siginfo.isdst then
+							main = false
+						end
+						return {group = "advtrains_signals_japan:5a", name = asp, main = main}
 					end,
 					set_aspect = function(pos, node, asp)
 						advtrains.ndb.swap_node(pos, {name = "advtrains_signals_japan:"..sigtype.."_"..(asp.name).."_"..rot, param2 = node.param2})
-- 
cgit v1.2.3


From 1f74697e85d456e97e201cdd9edef91a2df4fc14 Mon Sep 17 00:00:00 2001
From: orwell <orwell@bleipb.de>
Date: Mon, 8 Apr 2024 21:46:43 +0200
Subject: Fully implement and test new aspect support/distant signalling on ks
 and japan signals

---
 advtrains_interlocking/signal_api.lua | 42 ++++++++++++++++++++++++-----------
 advtrains_signals_japan/init.lua      | 36 ++++++++++++++++++++++++------
 advtrains_signals_japan/mod.conf      |  6 +++++
 advtrains_signals_ks/init.lua         | 26 +++++++++++-----------
 4 files changed, 77 insertions(+), 33 deletions(-)
 create mode 100644 advtrains_signals_japan/mod.conf

(limited to 'advtrains_signals_japan')

diff --git a/advtrains_interlocking/signal_api.lua b/advtrains_interlocking/signal_api.lua
index ce3b03f..d27a045 100644
--- a/advtrains_interlocking/signal_api.lua
+++ b/advtrains_interlocking/signal_api.lua
@@ -80,7 +80,7 @@ ndef.advtrains = {
 		-- Node can set any other fields at its discretion. They are not touched.
 		-- Note: On first call advtrains automatically inserts into the ndef.advtrains table a main_aspects_lookup hashtable
 		-- Note: Pure distant signals (that cannot show halt) should NOT have a main_aspects table
-	apply_aspect = function(pos, main_aspect, rem_aspect, rem_aspinfo)
+	apply_aspect = function(pos, node, main_aspect, rem_aspect, rem_aspinfo)
 		-- set the node to show the desired aspect
 		-- called by advtrains when this signal's aspect group or the remote signal's aspect changes
 		-- MAY return the aspect_info. If it returns nil then get_aspect_info will be queried at a later point.
@@ -120,7 +120,7 @@ Signals that are possible start and end points for a route must satisfy:
 -- Database
 -- Signal Aspect store
 -- Stores for each signal the main aspect and other info, like the assigned remote signal
--- [signal encodePos] = { main_aspect = "proceed", [speed = 12], [remote = encodedPos] }
+-- [signal encodePos] = { name = "proceed", [speed = 12], [remote = encodedPos] }
 signal.aspects = {}
 
 -- Distant signal notification. Records for each signal the distant signals that refer to it
@@ -162,10 +162,11 @@ function signal.set_aspect(pos, main_asp_name, main_asp_speed, rem_pos, skip_dst
 	
 	-- if remote has changed, unregister from old remote
 	if old_remote and old_remote~=new_remote and signal.distant_refs[old_remote] then
+		atdebug("unregister old remote: ",old_remote,"from",main_pts)
 		signal.distant_refs[old_remote][main_pts] = nil
 	end
 		
-	signal.aspects[main_pts] = { main_aspect = main_asp_name, speed = main_asp_speed, remote = new_remote }
+	signal.aspects[main_pts] = { name = main_asp_name, speed = main_asp_speed, remote = new_remote }
 	-- apply aspect on main signal, this also checks new_remote
 	signal.reapply_aspect(main_pts)	
 	
@@ -198,10 +199,12 @@ end
 -- Notify distant signals of main_pts of a change in the aspect of this signal
 -- 
 function signal.notify_distants_of(main_pts, limit)
+	atdebug("notify_distants_of",advtrains.decode_pos(main_pts),"limit",limit)
 	if limit <= 0 then
 		return
 	end
 	local dstrefs = signal.distant_refs[main_pts]
+	atdebug("dstrefs",dstrefs,"")
 	if dstrefs then
 		for dst,_ in pairs(dstrefs) do
 			-- ensure that the backref is still valid
@@ -253,7 +256,7 @@ local function cache_mainaspects(ndefat)
 		-- always define halt aspect
 		halt = signal.MASP_HALT
 	}
-	for _,ma in ipairs(ndefat.main_aspects) then
+	for _,ma in ipairs(ndefat.main_aspects) do
 		ndefat.main_aspects_lookup[ma.name] = ma
 	end
 end
@@ -263,32 +266,37 @@ function signal.get_aspect_internal(pos, aspt)
 		-- oh, no main aspect, nevermind
 		return nil, aspt.remote, nil
 	end
+	atdebug("get_aspect_internal",pos,aspt)
 	-- look aspect in nodedef
 	local node = advtrains.ndb.get_node_or_nil(pos)
 	local ndef = node and minetest.registered_nodes[node.name]
 	local ndefat = ndef and ndef.advtrains
 	-- only if signal defines main aspect and its set in aspt
-	if ndefat and ndefat.main_aspects and aspt.main_aspect then
+	if ndefat and ndefat.main_aspects and aspt.name then
 		if not ndefat.main_aspects_lookup then
 			cache_mainaspects(ndefat)
 		end
 		local masp = ndefat.main_aspects_lookup[aspt.name]
+		if not masp then
+			atwarn(pos,"invalid main aspect",aspt.name,"valid are",ndefat.main_aspects_lookup)
+			return nil, aspt.remote, node, ndef
+		end
 		-- if speed, then apply speed
 		if masp.speed and aspt.speed then
 			masp = table.copy(masp)
 			masp.speed = aspt.speed
 		end
-		return masp, aspt.remote, ndef
+		return masp, aspt.remote, node, ndef
 	end
 	-- invalid node or no main aspect, return nil for masp
-	return nil, aspt.remote, ndef
+	return nil, aspt.remote, node, ndef
 end
 
 -- For the signal at pos, get the "aspect info" table. This contains the speed signalling information at this location
 function signal.get_aspect_info(pos)
 	-- get aspect internal
 	local aspt = signal.aspects[advtrains.encode_pos(pos)]
-	local masp, remote, ndef = signal.get_aspect_internal(pos, aspt)
+	local masp, remote, node, ndef = signal.get_aspect_internal(pos, aspt)
 	-- call into ndef
 	if ndef.advtrains and ndef.advtrains.get_aspect_info then
 		return ndef.advtrains.get_aspect_info(pos, masp)
@@ -305,30 +313,38 @@ end
 function signal.reapply_aspect(pts)
 	-- get aspt
 	local aspt = signal.aspects[pts]
+	atdebug("reapply_aspect",advtrains.decode_pos(pts),"aspt",aspt)
 	if not aspt then
 		return -- oop, nothing to do
 	end
 	-- resolve mainaspect table by name
 	local pos = advtrains.decode_pos(pts)
-	-- note: masp may be nil, when aspt.main_aspect was nil. Valid case for distant-only signals
-	local masp, remote, ndef = signal.get_aspect_internal(pos, aspt)
+	-- note: masp may be nil, when aspt.name was nil. Valid case for distant-only signals
+	local masp, remote, node, ndef = signal.get_aspect_internal(pos, aspt)
 	-- if we have remote, resolve remote
 	local rem_masp, rem_aspi
 	if remote then
+		-- register in remote signal as distant
+		if not signal.distant_refs[remote] then
+			signal.distant_refs[remote] = {}
+		end
+		signal.distant_refs[remote][pts] = true
 		local rem_aspt = signal.aspects[remote]
+		atdebug("resolving remote",advtrains.decode_pos(remote),"aspt",rem_aspt)
 		if rem_aspt and rem_aspt.name then
 			local rem_pos = advtrains.decode_pos(remote)
-			rem_masp, _, rem_ndef = signal.get_aspect_internal(rem_pos, rem_aspt)
+			rem_masp, _, _, rem_ndef = signal.get_aspect_internal(rem_pos, rem_aspt)
 			if rem_masp then
 				if rem_ndef.advtrains and rem_ndef.advtrains.get_aspect_info then
-					rem_aspi = rem_ndef.advtrains.get_aspect_info(pos, rem_masp)
+					rem_aspi = rem_ndef.advtrains.get_aspect_info(rem_pos, rem_masp)
 				end
 			end
 		end
 	end
 	-- call into ndef
+	atdebug("applying to",pos,": main_asp",masp,"rem_masp",rem_masp,"rem_aspi",rem_aspi)
 	if ndef.advtrains and ndef.advtrains.apply_aspect then
-		return ndef.advtrains.apply_aspect(pos, masp, rem_masp, rem_aspi)
+		ndef.advtrains.apply_aspect(pos, node, masp, rem_masp, rem_aspi)
 	end
 	-- notify trains
 	signal.notify_trains(pos)
diff --git a/advtrains_signals_japan/init.lua b/advtrains_signals_japan/init.lua
index 84373a9..eb39f85 100644
--- a/advtrains_signals_japan/init.lua
+++ b/advtrains_signals_japan/init.lua
@@ -275,6 +275,7 @@ minetest.register_node("advtrains_signals_japan:pole_0", {
 	drop = "advtrains_signals_japan:pole_0",
 })
 
+--[[
 advtrains.interlocking.aspect.register_group {
 	name = "advtrains_signals_japan:5a",
 	label = S("Japanese signal"),
@@ -301,7 +302,7 @@ advtrains.interlocking.aspect.register_group {
 		"restrictedspeed",
 		"danger",
 	}
-}
+}]]
 
 local sigdefs = {}
 local lightcolors = {
@@ -316,6 +317,7 @@ local function process_signal(name, sigdata, isrpt)
 	def.textures = tx
 	def.desc = sigdata.desc
 	def.isdst = isrpt
+	def.aspects = sigdata.aspects
 	local lights = sigdata.lights
 	local lightcount = #lights
 	if isrpt then
@@ -359,16 +361,17 @@ for sigtype, sigdata in pairs {
 		desc = "5A",
 		lights = {"yellow", "yellow", "red", "yellow", "green"},
 		aspects = {
-			{name = "clear", lights = {5}, main = -1},
-			{name = "reducedspeed", lights = {2, 5}},
-			{name = "caution", lights = {4}},
-			{name = "restrictedspeed", lights = {1, 4}},
-			{name = "danger", lights = {3}, main = 0},
+			{name = "clear", description = S"Clear (proceed)", lights = {5}, main = -1},
+			{name = "reducedspeed", description = S"Reduced speed", lights = {2, 5}, main = 12},
+			{name = "caution", description = S"Caution", lights = {4}},
+			{name = "restrictedspeed", description = S"Restricted speed", lights = {1, 4}, main = 6},
+			{name = "danger", description = S"Danger (halt)", lights = {3}, main = 0},
 		}
 	}
 } do
 	sigdefs["main_"..sigtype] = process_signal(sigtype, sigdata)
-	sigdefs["rpt_"..sigtype] = process_signal(sigtype, sigdata, true)
+	-- TODO re-enable this once ready
+	--sigdefs["rpt_"..sigtype] = process_signal(sigtype, sigdata, true)
 end
 
 for k in pairs(sigdefs) do
@@ -412,6 +415,24 @@ for _, rtab in ipairs {
 				inventory_image = siginfo.inventory_image,
 				drop = "advtrains_signals_japan:"..sigtype.."_danger_0",
 				advtrains = {
+					main_aspects = siginfo.aspects,
+					apply_aspect = function(pos, node, main_aspect, rem_aspect, rem_aspinfo)
+						local asp_name = main_aspect and main_aspect.name or "danger"
+						-- if this signal is clear and remote signal is restrictive (<= 10) then degrade to caution aspect
+						if not main_aspect or main_aspect.name == "halt" then
+							asp_name = "danger"
+						elseif main_aspect.name == "clear" and rem_aspinfo and rem_aspinfo.main and rem_aspinfo.main >= 0 and rem_aspinfo.main <= 10 then
+							asp_name = "caution"
+						end
+						advtrains.ndb.swap_node(pos, {name="advtrains_signals_japan:"..sigtype.."_"..asp_name.."_"..rot, param2 = node.param2})
+					end,
+					get_aspect_info = function(pos, main_aspect)
+						return {
+							main = main_aspect.main,
+							proceed_as_main = true,
+						}
+					end,
+				--[[
 					supported_aspects = {
 						group = "advtrains_signals_japan:5a",
 						name = siginfo.suppasp_names,
@@ -428,6 +449,7 @@ for _, rtab in ipairs {
 					set_aspect = function(pos, node, asp)
 						advtrains.ndb.swap_node(pos, {name = "advtrains_signals_japan:"..sigtype.."_"..(asp.name).."_"..rot, param2 = node.param2})
 					end,
+				]]
 				},
 				on_rightclick = advtrains.interlocking.signal_rc_handler,
 				can_dig = advtrains.interlocking.signal_can_dig,
diff --git a/advtrains_signals_japan/mod.conf b/advtrains_signals_japan/mod.conf
new file mode 100644
index 0000000..8cb2cb3
--- /dev/null
+++ b/advtrains_signals_japan/mod.conf
@@ -0,0 +1,6 @@
+name=advtrains_signals_japan
+title=Advtrains Interlocking Signal Set - Japanese Signals
+description=Japanese signal set for the Advanced Trains Interlocking system
+author=yw05
+
+depends=advtrains_interlocking
diff --git a/advtrains_signals_ks/init.lua b/advtrains_signals_ks/init.lua
index 0a43db0..0ed03bb 100755
--- a/advtrains_signals_ks/init.lua
+++ b/advtrains_signals_ks/init.lua
@@ -51,7 +51,7 @@ end
 local applyaspectf_main = function(rot)
  return function(pos, node, main_aspect, dst_aspect, dst_aspect_info)
 	-- set zs3 signal to show speed according to main_aspect
-	setzs3(pos, asp.zs3, rot)
+	setzs3(pos, main_aspect.zs3, rot)
 	-- select appropriate lamps based on mainaspect and dst
 	if main_aspect.shunt then
 		advtrains.ndb.swap_node(pos, {name="advtrains_signals_ks:hs_shunt_"..rot, param2 = node.param2})
@@ -81,43 +81,43 @@ end
 -- Actual signal aspect is chosen based on this and the Dst signal.
 local mainaspects_main = {
 	{
-		name = "proceed"
+		name = "proceed",
 		description = "Proceed",
 		zs3 = "off"
 	},
 	{
-		name = "shunt"
+		name = "shunt",
 		description = "Shunt",
 		zs3 = "off",
 		shunt = true,
 	},
 	{
-		name = "proceed_16"
+		name = "proceed_16",
 		description = "Proceed (speed 16)",
 		zs3 = "16",
 	},
 	{
-		name = "proceed_12"
+		name = "proceed_12",
 		description = "Proceed (speed 12)",
 		zs3 = "12",
 	},
 	{
-		name = "proceed_8"
+		name = "proceed_8",
 		description = "Proceed (speed 8)",
 		zs3 = "8",
 	},
 	{
-		name = "proceed_6"
+		name = "proceed_6",
 		description = "Proceed (speed 6)",
 		zs3 = "6",
 	},
 	{
-		name = "proceed_4"
+		name = "proceed_4",
 		description = "Proceed (speed 4)",
 		zs3 = "4",
 	},
 	{
-		name = "halt"
+		name = "halt",
 		description = "Halt",
 		zs3 = "off",
 		halt = true,
@@ -140,12 +140,12 @@ end
 -- Shunt signals have only two states, distant doesn't matter
 local mainaspects_shunt = {
 	{
-		name = "shunt"
+		name = "shunt",
 		description = "Shunt",
 		shunt = true,
 	},
 	{
-		name = "halt"
+		name = "halt",
 		description = "Halt",
 		halt = true,
 	},
@@ -168,7 +168,7 @@ for _, rtab in ipairs({
 	}) do
 	local rot = rtab.rot
 	for typ, prts in pairs({
-			danger   = {asp = advtrains.interlocking.DANGER, n = "slow", ici=true},
+			danger   = {asp = advtrains.interlocking.signal.ASPI_HALT, n = "slow", ici=true},
 			slow     = {
 				asp = function(pos)
 					return { main = getzs3(pos) or -1, proceed_as_main = true, dst = 0 }
@@ -230,7 +230,7 @@ for _, rtab in ipairs({
 			drop = "advtrains_signals_ks:hs_danger_0",
 			inventory_image = "advtrains_signals_ks_hs_inv.png",
 			advtrains = {
-				main_aspects = mainaspects_main
+				main_aspects = mainaspects_main,
 				apply_aspect = applyaspectf_main(rot),
 				get_aspect_info = afunc,
 			},
-- 
cgit v1.2.3