aboutsummaryrefslogtreecommitdiff
path: root/advtrains_interlocking/ars.lua
diff options
context:
space:
mode:
Diffstat (limited to 'advtrains_interlocking/ars.lua')
-rw-r--r--advtrains_interlocking/ars.lua392
1 files changed, 392 insertions, 0 deletions
diff --git a/advtrains_interlocking/ars.lua b/advtrains_interlocking/ars.lua
new file mode 100644
index 0000000..99401d4
--- /dev/null
+++ b/advtrains_interlocking/ars.lua
@@ -0,0 +1,392 @@
+-- ars.lua
+-- automatic routesetting
+
+--[[
+ The "ARS table" and its effects:
+ Every route has (or can have) an associated ARS table:
+ ars = {
+ [n] = {
+ ln = "<line>" -- either line
+ rc = "<routingcode>" -- or routingcode
+ tl = {min=1, max=2} -- or train length in meters
+ n = true/false -- true = logical not (matches everything that does not have this line/rc)
+ conj = { -- and conjunction, optional. This must be true in addition to the main rule
+ ln=... / rc=... / n=... -- like toplevel
+ conj=... -- can be nested
+ -- note that conj cannot have prio, in inherits the prio from main rule
+ }
+ prio = <num> -- optional, a priority number. If set, enables "multi-ARS" where train can wait for multiple routes at once
+ -- or
+ c="<a comment>"
+ }
+ default = true -- Route is the default route for trains
+ default_prio -- optional, priority for multi-ars with default route
+ default_conj = {...} -- optional, conditions (conjunction) that need to be fulfilled for this to be considered default route
+ }
+
+ In case a train matches the ARS rules of multiple routes, precedence is as follows:
+ 1. train matches rules without priority in one or more routes -> first matching route is unconditionally set
+ 2. train matches rules with priority in one or more routes -> all of the matching routes are set (multi-ars)
+ in the order given by priority, first available route is set
+ 3. route is default=true, default_prio=nil and train matches default_conj (if present) -> first default route is set
+ 4. one or more routes are default=true, with default_prio set,and train matches default_conj (if present)
+ -> all of the matching routes are set (multi-ars) in the order given by priority, first available route is set
+
+ For editing, those tables are transformed into lines in a text area:
+ {ln=...} -> LN ...
+ {rc=...} -> RC ...
+ {c=...} -> #...
+ {default=true} -> *
+ n -> ! (e.g. ln=..., n=true -> !LN ...)
+ prio -> <num> (e.g. ln=..., prio=1 -> 1 LN ...)
+
+ conj -> goes on the next line, with an & prepended, e.g.:
+ {ln="S1", conj={rc="Left"}} ->
+ LN S1
+ & RC Left
+
+ Example combining everything:
+ ars = {
+ [1] = {
+ ln = "S1"
+ n = true
+ prio = 4
+ conj = {
+ rc = "R4"
+ }
+ }
+ default = true
+ default_prio = 2
+ default_conj = {
+ rc = "R5"
+ n = true
+ }
+ } ->
+ 4 !LN S1
+ & RC R4
+ 2 *
+ & !RC R5
+
+]]
+
+local il = advtrains.interlocking
+local S = il.translate
+
+local function parse_trainlen(tlstr)
+ mins, maxs = string.match(tlstr, "^(%d*)%-(%d+)$")
+ if mins and maxs then
+ return {min=tonumber(mins), max=tonumber(maxs)}
+ end
+ return {min=tonumber(tlstr)}
+ -- if it's not parseable at all it will return an empty table which means invalid
+end
+local function trainlen_to_str(tl)
+ if tl.min and tl.max then
+ return tl.min.."-"..tl.max
+ elseif tl.min then
+ return tl.min
+ elseif tl.max then
+ return "0-"..tl.max
+ else
+ return "?"
+ end
+end
+
+
+local function conj_to_text(conj, txt)
+ while conj do
+ n = ""
+ if conj.n then
+ n = "!"
+ end
+ if conj.ln then
+ txt[#txt+1] = "& "..n.."LN "..conj.ln
+ elseif conj.rc then
+ txt[#txt+1] = "& "..n.."RC "..conj.rc
+ elseif conj.tl then
+ txt[#txt+1] = "& "..n.."TL "..trainlen_to_str(conj.tl)
+ end
+ conj = conj.conj
+ end
+end
+
+-- The ARS data are saved in a table format, but are entered in text format. Utility functions to transform between both.
+function il.ars_to_text(arstab)
+ if not arstab then
+ return ""
+ end
+
+ local txt = {}
+
+ for i, arsent in ipairs(arstab) do
+ local prio = ""
+ if arsent.prio then
+ prio = arsent.prio.." "
+ end
+ local n = ""
+ if arsent.n then
+ n = "!"
+ end
+ if arsent.ln then
+ txt[#txt+1] = prio..n.."LN "..arsent.ln
+ elseif arsent.rc then
+ txt[#txt+1] = prio..n.."RC "..arsent.rc
+ elseif arsent.tl then
+ txt[#txt+1] = prio..n.."TL "..trainlen_to_str(arsent.tl)
+ elseif arsent.c then
+ txt[#txt+1] = "#"..arsent.c
+ end
+ conj_to_text(arsent.conj, txt)
+ end
+
+ if arstab.default then
+ local prio = ""
+ if arstab.default_prio then
+ prio = arstab.default_prio.." "
+ end
+ txt[#txt+1] = prio.."*"
+ conj_to_text(arstab.default_conj, txt)
+ end
+ return table.concat(txt, "\n")
+end
+
+local function parse_ruleexp(line)
+ local excl, key, val = string.match(line, "^%s*(!?)%s*([RLT][CNL])%s+(.+)%s*$")
+ if key == "RC" then
+ return {rc=val, n=(excl=="!")}
+ elseif key == "LN" then
+ return {ln=val, n=(excl=="!")}
+ elseif key == "TL" then
+ return {tl=parse_trainlen(val), n=(excl=="!")}
+ end
+end
+
+function il.text_to_ars(t)
+ if not string.match(t, "%S+") then
+ return nil
+ end
+ local arstab = {}
+ local previtem
+ for line in string.gmatch(t, "[^\r\n]+") do
+ -- a) comment
+ local ct = string.match(line, "^#(.*)$")
+ if ct then
+ arstab[#arstab+1] = {c = ct}
+ previtem = nil
+ else
+ -- b) Conjunction to the previous item
+ local conline = string.match(line, "^%s*&(.+)$")
+ if conline then
+ local conj = parse_ruleexp(conline)
+ if conj and previtem==true then
+ -- previtem was default
+ arstab.default_conj = conj
+ previtem = conj
+ elseif conj and previtem then
+ previtem.conj = conj
+ previtem = conj
+ else
+ -- dont know what to do with line, put as comment
+ arstab[#arstab+1] = {c = "? "..line}
+ previtem = nil
+ end
+ else
+ -- c) Normal rule spec
+ local prio, ruleline = string.match(line, "^%s*([0-9]*)%s*(.+)%s*$")
+ if ruleline == "*" then
+ -- ruleline is the asterisk, this is default
+ arstab.default = true
+ arstab.default_prio = tonumber(prio) -- evals to nil if not given
+ previtem = true -- marks that previtem was asterisk
+ elseif ruleline then
+ -- ruleline is present, parse it
+ local rule = parse_ruleexp(ruleline)
+ if not rule then
+ -- dont know what to do with line, put as comment
+ arstab[#arstab+1] = {c = "? "..line}
+ previtem = nil
+ else
+ rule.prio = tonumber(prio) -- evals to nil if not given
+ arstab[#arstab+1] = rule
+ previtem = rule
+ end
+ else
+ -- d) nothing else works, save line as comment
+ arstab[#arstab+1] = {c = "? "..line}
+ previtem = nil
+ end
+ end
+ end
+ end
+ return arstab
+end
+
+
+local function match_arsent(arsent, train)
+ local rule_matches = false
+ if arsent.ln then
+ local line = train.line
+ rule_matches = line and arsent.ln == line
+ if arsent.n then rule_matches = not rule_matches end
+ elseif arsent.rc then
+ local routingcode = train.routingcode
+ rule_matches = routingcode and string.find(" "..routingcode.." ", " "..arsent.rc.." ", nil, true)
+ if arsent.n then rule_matches = not rule_matches end
+ elseif arsent.tl then
+ local trainlen = train.trainlen
+ local lmin, lmax = arsent.tl.min, arsent.tl.max
+ if lmin and lmax then
+ rule_matches = (trainlen >= lmin) and (trainlen < lmax)
+ elseif lmin then
+ rule_matches = (trainlen >= lmin)
+ elseif lmax then
+ rule_matches = (trainlen < lmax)
+ else
+ -- errorneous entry never matches
+ end
+ if arsent.n then rule_matches = not rule_matches end
+ end
+ if rule_matches then
+ -- if the entry has a conjunction, go on checking
+ if arsent.conj then
+ return match_arsent(arsent.conj, train)
+ else
+ return true
+ end
+ else
+ return false
+ end
+end
+
+-- Given an ARS rule table, check whether any of the clauses in it match the train.
+-- Returns: match_specific, match_default
+-- match_specific: One of the clauses explicitly matched (if this is non-false, match_default is not checked and always given false)
+-- match_default: The default clause (*) matched (as well as any conjunctions attached to the default clause)
+-- both of these can be either true (unconditional match), a number (priority for multi-ars) or false
+function il.ars_check_rule_match(ars, train)
+ if not ars then
+ return nil, nil
+ end
+ for arskey, arsent in ipairs(ars) do
+ local rule_matches = match_arsent(arsent, train)
+ if rule_matches then
+ return (arsent.prio or true), nil
+ end
+ end
+ if ars.default then
+ local def_matches = true
+ if ars.default_conj then
+ def_matches = match_arsent(ars.default_conj, train)
+ end
+ if def_matches then
+ return false, (ars.default_prio or true)
+ end
+ end
+ return false,false
+end
+
+local function sort_priority(sprio)
+ -- insertion sort
+ local order = {}
+ local oprio = {}
+ for rteid, prio in pairs(sprio) do
+ local inspos = 1
+ while order[inspos] do
+ if oprio[inspos] > prio then
+ -- next item has higher priority number (= less urgent), insert before it
+ break
+ elseif oprio[inspos] == prio and order[inspos] > rteid then
+ -- next item has same priority as current and a higher routeid, insert before it
+ break
+ end
+ inspos = inspos + 1
+ end
+ table.insert(order, inspos, rteid)
+ table.insert(oprio, inspos, prio)
+ end
+ --atdebug("sort_priority",sprio,"result",order,oprio)
+ if #order == 1 then
+ return order[1] -- only one route, table doesnt make sense
+ end
+ return order
+end
+
+local function find_rtematch(routes, train)
+ local sprio = {}
+ local default = nil
+ local dprio = {}
+ for rteid, route in ipairs(routes) do
+ if route.ars then
+ local mspec, mdefault = il.ars_check_rule_match(route.ars, train)
+ --atdebug("route",rteid,"ars",route.ars,"gives", mspec, mdefault)
+ if mspec == true then
+ return rteid
+ elseif mspec then
+ sprio[rteid] = mspec
+ end
+ if mdefault == true then
+ if not default then default = rteid end
+ elseif mdefault then
+ dprio[rteid] = mdefault
+ end
+ end
+ end
+ if next(sprio) then
+ return sort_priority(sprio)
+ elseif default then
+ return default
+ elseif next(dprio) then
+ return sort_priority(dprio)
+ else
+ return nil
+ end
+end
+
+
+function advtrains.interlocking.ars_check(signalpos, train, trig_from_dst)
+ -- check for distant signal
+ -- this whole check must be delayed until after the route setting has taken place,
+ -- because before that the distant signal is yet unknown
+ if not trig_from_dst then
+ minetest.after(0.5, function()
+ -- does signal have dst?
+ local _, remote = il.signal.get_aspect(signalpos)
+ if remote then
+ advtrains.interlocking.ars_check(remote, train, true)
+ end
+ end)
+ end
+
+ local sigd = il.db.get_sigd_for_signal(signalpos)
+ local tcbs = sigd and il.db.get_tcbs(sigd)
+ -- trigger ARS on this signal
+ if tcbs and tcbs.routes then
+
+ if tcbs.ars_disabled or tcbs.ars_ignore_next then
+ -- No-ARS mode of signal.
+ -- ignore...
+ -- Note: ars_ignore_next is set by signalling formspec when route is cancelled
+ tcbs.ars_ignore_next = nil
+ return
+ end
+ if trig_from_dst and tcbs.no_dst_ars_trig then
+ -- signal not to be triggered from distant
+ return
+ end
+
+ if tcbs.routeset then
+ -- ARS is not in effect when a route is already set
+ -- just "punch" routesetting, just in case callback got lost.
+ minetest.after(0, il.route.update_route, sigd, tcbs, nil, nil)
+ return
+ end
+
+ local rteid = find_rtematch(tcbs.routes, train)
+ if rteid then
+ --atdebug("Ars setting ",rteid)
+ --delay routesetting, it should not occur inside train step
+ -- using after here is OK because that gets called on every path recalculation
+ minetest.after(0, il.route.update_route, sigd, tcbs, rteid, nil, S("Train @1", train.id))
+ end
+ end
+end