349 lines
11 KiB
Lua
349 lines
11 KiB
Lua
-- Setting and clearing routes
|
|
|
|
-- 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
|
|
local c_tcbs, c_ts_id, c_ts, c_rseg, c_lckp
|
|
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, "No TCB found at "..sigd_to_string(c_sigd)..". Please reconfigure route!"
|
|
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, "No track section adjacent to "..sigd_to_string(c_sigd)..". Please reconfigure route!"
|
|
end
|
|
c_ts = ildb.get_ts(c_ts_id)
|
|
c_rseg = route[i]
|
|
c_lckp = {}
|
|
|
|
if 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, "Section '"..c_ts.name.."' already has route set from "..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 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, "Section '"..c_ts.name.."' is occupied!", c_ts_id, nil
|
|
end
|
|
|
|
for pts, state in pairs(c_rseg.locks) do
|
|
local confl = ilrs.has_route_lock(pts, state)
|
|
|
|
local pos = minetest.string_to_pos(pts)
|
|
if advtrains.is_passive(pos) then
|
|
local cstate = advtrains.getstate(pos)
|
|
if cstate ~= state then
|
|
local confl = ilrs.has_route_lock(pts)
|
|
if confl then
|
|
if not try then atwarn("Encountered route lock while a real run of routesetting routine, at position",pts,"while setting route",rtename,"of",signal) end
|
|
return false, "Lock conflict at "..pts..", Held locked by:\n"..confl, nil, pts
|
|
elseif not try then
|
|
advtrains.setstate(pos, state)
|
|
end
|
|
end
|
|
if not try then
|
|
ilrs.add_route_lock(pts, c_ts_id, "Route '"..rtename.."' from signal '"..signalname.."'", signal)
|
|
c_lckp[#c_lckp+1] = pts
|
|
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, "No passive component at "..pts..". Please reconfigure route!"
|
|
end
|
|
end
|
|
-- reserve ts and write locks
|
|
if not try then
|
|
local nvar = c_rseg.next
|
|
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 = "Route '"..rtename.."' from signal '"..signalname.."', segment #"..i,
|
|
first = first,
|
|
}
|
|
c_ts.route_post = {
|
|
locks = c_lckp,
|
|
next = nvar,
|
|
}
|
|
if c_tcbs.signal then
|
|
c_tcbs.route_committed = true
|
|
c_tcbs.aspect = route.aspect or advtrains.interlocking.GENERIC_FREE
|
|
c_tcbs.route_rsn = nil
|
|
c_tcbs.route_origin = signal
|
|
advtrains.interlocking.update_signal_aspect(c_tcbs)
|
|
end
|
|
end
|
|
-- advance
|
|
first = nil
|
|
c_sigd = c_rseg.next
|
|
i = i + 1
|
|
end
|
|
|
|
return true
|
|
end
|
|
|
|
-- 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)
|
|
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, minetest.string_to_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.aspect = nil
|
|
c_tcbs.routeset = nil
|
|
c_tcbs.route_auto = nil
|
|
c_tcbs.route_origin = nil
|
|
|
|
advtrains.interlocking.update_signal_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). nil otherwise
|
|
-- cancel: true in combination with newrte=nil causes cancellation of the current route.
|
|
function ilrs.update_route(sigd, tcbs, newrte, cancel)
|
|
--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
|
|
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.aspect = nil
|
|
has_changed_aspect = true
|
|
tcbs.routeset = nil
|
|
tcbs.route_auto = nil
|
|
tcbs.route_rsn = nil
|
|
end
|
|
if newrte or tcbs.routeset then
|
|
if tcbs.route_committed then
|
|
return
|
|
end
|
|
if newrte then tcbs.routeset = newrte end
|
|
--atdebug("Setting:",tcbs.routeset)
|
|
local succ, rsn, cbts, cblk
|
|
if tcbs.routes[tcbs.routeset] then
|
|
succ, rsn, cbts, cblk = ilrs.set_route(sigd, tcbs.routes[tcbs.routeset])
|
|
else
|
|
succ = false
|
|
rsn = attrans("Route state changed.")
|
|
end
|
|
if not succ then
|
|
tcbs.route_rsn = rsn
|
|
--atdebug("Routesetting failed:",rsn)
|
|
-- 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:",tcbs.routeset)
|
|
has_changed_aspect = true
|
|
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.update_signal_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
|
|
|