diff options
Diffstat (limited to 'advtrains_interlocking/routesetting.lua')
| -rw-r--r-- | advtrains_interlocking/routesetting.lua | 493 |
1 files changed, 493 insertions, 0 deletions
diff --git a/advtrains_interlocking/routesetting.lua b/advtrains_interlocking/routesetting.lua new file mode 100644 index 0000000..eec1460 --- /dev/null +++ b/advtrains_interlocking/routesetting.lua @@ -0,0 +1,493 @@ +-- Setting and clearing routes + +-- Get current translator +local S = advtrains.interlocking.translate + +-- TODO duplicate +local lntrans = { "A", "B" } +local function sigd_to_string(sigd) + return minetest.pos_to_string(sigd.p).." / "..lntrans[sigd.s] +end + +local ildb = advtrains.interlocking.db +local ilrs = {} + +local sigd_equal = advtrains.interlocking.sigd_equal + +-- table containing locked points +-- also manual locks (maintenance a.s.o.) are recorded here +-- [pts] = { +-- [n] = { [by = <ts_id>], rsn = <human-readable text>, [origin = <sigd>] } +-- } +ilrs.rte_locks = {} +ilrs.rte_callbacks = { + ts = {}, + lck = {} +} + + +-- main route setting. First checks if everything can be set as designated, +-- then (if "try" is not set) actually sets it +-- returns: +-- true - route can be/was successfully set +-- false, message, cbts, cblk - something went wrong, what is contained in the message. +-- cbts: the ts id of the conflicting ts, cblk: the pts of the conflicting component +function ilrs.set_route(signal, route, try) + if not try then + local tsuc, trsn, cbts, cblk = ilrs.set_route(signal, route, true) + if not tsuc then + return false, trsn, cbts, cblk + end + end + + + -- we start at the tc designated by signal + local c_sigd = signal + local first = true + local i = 1 + local rtename = route.name + local signalname = (ildb.get_tcbs(signal).signal_name or "") .. sigd_to_string(signal) + local c_tcbs, c_ts_id, c_ts, c_rseg, c_lckp + -- signals = { { pos = ., tcbs_ref = <tcbs>, role = "main_distant", main_aspect = nil, dst_type = "next_main" or "none" } + local signals = {} + local nodst + while c_sigd and i<=#route do + c_tcbs = ildb.get_tcbs(c_sigd) + if not c_tcbs then + if not try then atwarn("Did not find TCBS",c_sigd,"while setting route",rtename,"of",signal) end + return false, S("No TCB found at @1. Please update or reconfigure route!", sigd_to_string(c_sigd)) + end + if i == 1 then + nodst = c_tcbs.nodst + end + c_ts_id = c_tcbs.ts_id + if not c_ts_id then + if not try then atwarn("Encountered End-Of-Interlocking while setting route",rtename,"of",signal) end + return false, S("No track section adjacent to @1. Please reconfigure route!", sigd_to_string(c_sigd)) + end + c_ts = ildb.get_ts(c_ts_id) + c_rseg = route[i] + c_lckp = {} + + if not c_ts then + if not try then atwarn("Encountered ts missing during a real run of routesetting routine, at ts=",c_ts_id,"while setting route",rtename,"of",signal) end + return false, S("Section '@1' not found!", c_ts_id), c_ts_id, nil + elseif c_ts.route then + if not try then atwarn("Encountered ts lock during a real run of routesetting routine, at ts=",c_ts_id,"while setting route",rtename,"of",signal) end + return false, S("Section '@1' already has route set from @2:", (c_ts.name or c_ts_id), sigd_to_string(c_ts.route.origin)) + .."\n"..c_ts.route.rsn, c_ts_id, nil + end + if c_ts.trains and #c_ts.trains>0 then + if c_rseg.call_on then + --atdebug("Routesetting: Call-on situation in", c_ts_id) + else + if not try then atwarn("Encountered ts occupied during a real run of routesetting routine, at ts=",c_ts_id,"while setting route",rtename,"of",signal) end + return false, S("Section '@1' is occupied!", (c_ts.name or c_ts_id)), c_ts_id, nil + end + end + + -- collect locks from rs cache and from route def + local c_locks = {} + if route.use_rscache and c_ts.rs_cache and c_rseg.next then + -- rscache needs to be enabled, present and next must be defined + local start_pkey = advtrains.encode_pos(c_sigd.p) + local end_pkey = advtrains.encode_pos(c_rseg.next.p) + if c_ts.rs_cache[start_pkey] and c_ts.rs_cache[start_pkey][end_pkey] then + for lp,lst in pairs(c_ts.rs_cache[start_pkey][end_pkey]) do + --atdebug("Add lock from RSCache:",lp,"->",lst) + c_locks[lp] = lst + end + elseif not try then + atwarn("While setting route",rtename,"of",signal,"segment "..i..",required path from",c_tcbs,"to",c_rseg.next,"was not found in the track section's RS cache. Please check!") + end + end + -- add all from locks, these override the rscache + for lpts,lst in pairs(c_rseg.locks) do + --atdebug("Add lock from Routedef:",lpts,"->",lst,"overrides",c_locks[lpts] or "none") + c_locks[lpts] = lst + end + + for lp, state in pairs(c_locks) do + local confl = ilrs.has_route_lock(lp, state) + + local pos = advtrains.decode_pos(lp) + if advtrains.is_passive(pos) then + local cstate = advtrains.getstate(pos) + if cstate ~= state then + local confl = ilrs.has_route_lock(lp) + if confl then + if not try then atwarn("Encountered route lock while a real run of routesetting routine, at position",pos,"while setting route",rtename,"of",signal) end + return false, S("Lock conflict at @1, Held locked by:", minetest.pos_to_string(pos)).."\n"..confl, nil, lp + elseif not try then + advtrains.setstate(pos, state) + end + end + if not try then + ilrs.add_route_lock(lp, c_ts_id, S("Route @1 from signal @2", rtename, signalname), signal) + c_lckp[#c_lckp+1] = lp + end + else + if not try then atwarn("Encountered route lock misconfiguration (no passive component) while a real run of routesetting routine, at position",pts,"while setting route",rtename,"of",signal) end + return false, S("Turnout/component missing at @1. Please update track section or reconfigure route!", minetest.pos_to_string(pos)) + end + end + -- sanity check, is section at next the same as the current? + local nvar = c_rseg.next + if nvar then + local re_tcbs = ildb.get_tcbs({p = nvar.p, s = (nvar.s==1) and 2 or 1}) + if (not re_tcbs or not re_tcbs.ts_id or re_tcbs.ts_id~=c_ts_id) + and route[i+1] then --FIX 2025-01-08: in old worlds the final TCB may be wrong (it didn't matter back then), don't error out here (route still shown invalid in UI) + if not try then atwarn("Encountered inconsistent ts (front~=back) while a real run of routesetting routine, at position",pts,"while setting route",rtename,"of",signal) end + return false, S("TCB at @1 has different section than previous TCB. Please update track section or reconfigure route!", minetest.pos_to_string(nvar.p)) + end + end + -- reserve ts and write locks + if not try then + if not route[i+1] then + -- We shouldn't use the "next" value of the final route segment, because this can lead to accidental route-cancelling of already set routes from another signal. + nvar = nil + end + c_ts.route = { + origin = signal, + entry = c_sigd, + rsn = S("Route @1 from signal @2, segment #@3", rtename, signalname, i), + first = first, + } + c_ts.route_post = { + locks = c_lckp, + next = nvar, + } + if c_tcbs.signal then + c_tcbs.route_committed = true + c_tcbs.route_origin = signal + -- determine route role + local ndef = advtrains.ndb.get_ndef(c_tcbs.signal) + local assign_dst = c_rseg.assign_dst + if assign_dst == nil then + assign_dst = true -- special behavior when assign_dst is nil (and not false): + -- defaults to true (= minimal user configuration overhead) (changed on 2025-09-23 after some consideration) + end + local sig_table = { + pos = c_tcbs.signal, + tcbs_ref = c_tcbs, + role = ndef and ndef.advtrains and ndef.advtrains.route_role, + main_aspect = c_rseg.main_aspect, + assign_dst = assign_dst + } + signals[#signals+1] = sig_table + end + end + -- advance + first = nil + c_sigd = c_rseg.next + i = i + 1 + end + + -- Get reference to signal at end of route + local last_mainsig = nil + if c_sigd then + local e_tcbs = ildb.get_tcbs(c_sigd) + local pos = e_tcbs and e_tcbs.signal + if pos then + last_mainsig = pos + end + end + for i = #signals, 1, -1 do + -- note the signals are iterated backwards. Switch depending on the role + local sig = signals[i] + -- apply mainaspect + sig.tcbs_ref.route_aspect = sig.main_aspect or "_default" -- or route.main_aspect : TODO this does not work if a distant signal is on the path! Implement per-sig aspects! + if sig.role == "distant" or sig.role == "distant_repeater" or sig.role == "main_distant" then + if last_mainsig then + -- assign the remote as the last mainsig if desired + if sig.assign_dst then + sig.tcbs_ref.route_remote = last_mainsig + end + -- if it wasn't a distant_repeater clear the mainsig + if sig.role ~= "distant_repeater" then + last_mainsig = false + end + end + end + if sig.role == "main" or sig.role == "main_distant" or sig.role == "end" then + -- record this as the new last mainsig + last_mainsig = sig.pos + end + -- for shunt signals nothing happens + -- update the signal aspect on map + advtrains.interlocking.signal.update_route_aspect(sig.tcbs_ref, i ~= 1) + end + + return true +end + +-- Change 2024-01-27: pts is not an encoded pos, not a pos-to-string! + +-- Checks whether there is a route lock that prohibits setting the component +-- to the wanted state. returns string with reasons on conflict +function ilrs.has_route_lock(pts) + -- look this up + local e = ilrs.rte_locks[pts] + if not e then return nil + elseif #e==0 then + ilrs.rte_locks[pts] = nil + return nil + end + local txts = {} + for _, ent in ipairs(e) do + txts[#txts+1] = ent.rsn + end + return table.concat(txts, "\n") +end + +-- adds route lock for position +function ilrs.add_route_lock(pts, ts, rsn, origin) + ilrs.free_route_locks_indiv(pts, ts, true) + local elm = {by=ts, rsn=rsn, origin=origin} + if not ilrs.rte_locks[pts] then + ilrs.rte_locks[pts] = { elm } + else + table.insert(ilrs.rte_locks[pts], elm) + end +end + +-- adds route lock for position +function ilrs.add_manual_route_lock(pts, rsn) + local elm = {rsn=rsn} + if not ilrs.rte_locks[pts] then + ilrs.rte_locks[pts] = { elm } + else + table.insert(ilrs.rte_locks[pts], elm) + end +end + +-- frees route locking for all points (components) that were set by this ts +function ilrs.free_route_locks(ts, lcks, nocallbacks) + for _,pts in pairs(lcks) do + ilrs.free_route_locks_indiv(pts, ts, nocallbacks) + end +end + +function ilrs.free_route_locks_indiv(pts, ts, nocallbacks) + -- legacy: if starts with bracket then pts is still in old pos_to_string format (may happen because ts.route_post is not migrated) + if string.match(pts, "^%(") then + atdebug("free_route_locks_indiv: converting position",pts) + pts = advtrains.encode_pos(minetest.string_to_pos(pts)) + end + local e = ilrs.rte_locks[pts] + if not e then return nil + elseif #e==0 then + ilrs.rte_locks[pts] = nil + return nil + end + local i = 1 + while i <= #e do + if e[i].by == ts then + --atdebug("free_route_locks_indiv",pts,"clearing entry",e[i].by,e[i].rsn) + table.remove(e,i) + else + i = i + 1 + end + end + -- This must be delayed, because this code is executed in-between a train step + -- TODO use luaautomation timers? + if not nocallbacks then + minetest.after(0, ilrs.update_waiting, "lck", pts) + minetest.after(0.5, advtrains.set_fallback_state, advtrains.decode_pos(pts)) + end +end +-- frees all route locks, even manual ones set with the tool, at a specific position +function ilrs.remove_route_locks(pts, nocallbacks) + ilrs.rte_locks[pts] = nil + -- This must be delayed, because this code is executed in-between a train step + -- TODO use luaautomation timers? + if not nocallbacks then + minetest.after(0, ilrs.update_waiting, "lck", pts) + end +end + + +-- starting from the designated sigd, clears all subsequent route and route_post +-- information from the track sections. +-- note that this does not clear the routesetting status from the entry signal, +-- only from the ts's +function ilrs.cancel_route_from(sigd) + -- we start at the tc designated by signal + local c_sigd = sigd + local c_tcbs, c_ts_id, c_ts, c_rseg, c_lckp + while c_sigd do + --atdebug("cancel_route_from: at sigd",c_sigd) + c_tcbs = ildb.get_tcbs(c_sigd) + if not c_tcbs then + atwarn("Failed to cancel route, no TCBS at",c_sigd) + return false + end + + --atdebug("cancelling",c_ts.route.rsn) + -- clear signal aspect and routesetting state + c_tcbs.route_committed = nil + c_tcbs.route_aspect = nil + c_tcbs.route_remote = nil + c_tcbs.routeset = nil + c_tcbs.routeset_trigger = nil + c_tcbs.route_auto = nil + c_tcbs.route_origin = nil + + advtrains.interlocking.signal.update_route_aspect(c_tcbs) + + c_ts_id = c_tcbs.ts_id + if not c_tcbs then + atwarn("Failed to cancel route, end of interlocking at",c_sigd) + return false + end + c_ts = ildb.get_ts(c_ts_id) + + if not c_ts + or not c_ts.route + or not sigd_equal(c_ts.route.entry, c_sigd) then + --atdebug("cancel_route_from: abort (eoi/no route):") + return false + end + + c_ts.route = nil + + if c_ts.route_post then + advtrains.interlocking.route.free_route_locks(c_ts_id, c_ts.route_post.locks) + c_sigd = c_ts.route_post.next + else + c_sigd = nil + end + c_ts.route_post = nil + minetest.after(0, advtrains.interlocking.route.update_waiting, "ts", c_ts_id) + end + --atdebug("cancel_route_from: done (no final sigd)") + return true +end + +-- TCBS Routesetting helper: generic update function for +-- route setting +-- Call this function to set and cancel routes! +-- sigd, tcbs: self-explanatory +-- newrte: If a new route should be set, the route index of it (in tcbs.routes). Can also be a table (multi-ars). nil otherwise +-- cancel: true in combination with newrte=nil causes cancellation of the current route. +-- trigger: The reason for setting the route +function ilrs.update_route(sigd, tcbs, newrte, cancel, trigger) + --atdebug("Update_Route for",sigd,tcbs.signal_name) + local has_changed_aspect = false + if tcbs.route_origin and not sigd_equal(tcbs.route_origin, sigd) then + --atdebug("Signal not in control, held by",tcbs.signal_name) + return + end + -- clear route_rsn, it will be set again if needed + tcbs.route_rsn = nil + if (newrte and tcbs.routeset and tcbs.routeset ~= newrte) or cancel then + if tcbs.route_committed then + --atdebug("Cancelling:",tcbs.routeset) + advtrains.interlocking.route.cancel_route_from(sigd) + end + tcbs.route_committed = nil + tcbs.route_aspect = nil + tcbs.route_remote = nil + has_changed_aspect = true + tcbs.routeset = nil + tcbs.routeset_trigger = nil + tcbs.route_auto = nil + end + if newrte or tcbs.routeset then + if tcbs.route_committed then + return + end + if newrte then + if type(newrte)=="table" and not next(newrte) then + error("update_route got multi-ARS with empty table, this is not allowed") + end + tcbs.routeset = newrte + tcbs.routeset_trigger = trigger + else + if type(tcbs.routeset)=="table" and not next(tcbs.routeset) then + -- just unset, don't error + atwarn(sigd, "had multi-ARS route set with empty list! Cancelled!") + tcbs.routeset = nil + tcbs.routeset_trigger = nil + return + end + end + --atdebug("Setting:",tcbs.routeset) + -- check: single-ars or multi-ars? + local multi_rte + if type(tcbs.routeset) == "table" then + multi_rte = tcbs.routeset + else + multi_rte = {tcbs.routeset} + end + for multi_idx, rteid in ipairs(multi_rte) do + local succ, rsn, cbts, cblk + local route = tcbs.routes[rteid] + if route then + succ, rsn, cbts, cblk = ilrs.set_route(sigd, route) + else + succ = false + rsn = attrans("Route with index @1 not found", rteid) + end + if not succ then + if multi_idx==1 then + tcbs.route_rsn = rsn + else + tcbs.route_rsn = (tcbs.route_rsn or "").."\n"..rsn + end + --atdebug("Routesetting",rteid,"failed:",rsn,"(multi-idx",multi_idx,")") + -- add cbts or cblk to callback table + if cbts then + --atdebug("cbts =",cbts) + if not ilrs.rte_callbacks.ts[cbts] then ilrs.rte_callbacks.ts[cbts]={} end + advtrains.insert_once(ilrs.rte_callbacks.ts[cbts], sigd, sigd_equal) + end + if cblk then + --atdebug("cblk =",cblk) + if not ilrs.rte_callbacks.lck[cblk] then ilrs.rte_callbacks.lck[cblk]={} end + advtrains.insert_once(ilrs.rte_callbacks.lck[cblk], sigd, sigd_equal) + end + else + --atdebug("Committed Route:",rteid,"(multi-idx",multi_idx,")") + -- replace multi_route by single actually committed route + tcbs.routeset = rteid + -- set_route now sets the signal aspects + --has_changed_aspect = true + -- route success. apply default_autoworking flag if requested + if route.default_autoworking then + tcbs.route_auto = true --FIX 2025-01-08: never set it to false if it was true! + end + -- break out of the for loop, dont try any more routes + break + end + end + end + if has_changed_aspect then + -- FIX: prevent an minetest.after() loop caused by update_signal_aspect dispatching path invalidation, which in turn calls ARS again + advtrains.interlocking.signal.update_route_aspect(tcbs) + end + advtrains.interlocking.update_player_forms(sigd) +end + +-- Try to re-set routes that conflicted with this point +-- sys can be one of "ts" and "lck" +-- key is then ts_id or pts respectively +function ilrs.update_waiting(sys, key) + --atdebug("update_waiting:",sys,".",key) + local t = ilrs.rte_callbacks[sys][key] + ilrs.rte_callbacks[sys][key] = nil + if t then + for _,sigd in ipairs(t) do + --atdebug("Updating", sigd) + -- While these are run, the table we cleared before may be populated again, which is in our interest. + -- (that's the reason we needed to copy it) + local tcbs = ildb.get_tcbs(sigd) + if tcbs then + ilrs.update_route(sigd, tcbs) + end + end + end +end + +advtrains.interlocking.route = ilrs + |
