diff options
Diffstat (limited to 'advtrains_interlocking/database.lua')
| -rw-r--r-- | advtrains_interlocking/database.lua | 966 |
1 files changed, 684 insertions, 282 deletions
diff --git a/advtrains_interlocking/database.lua b/advtrains_interlocking/database.lua index e23b0e5..49ca13d 100644 --- a/advtrains_interlocking/database.lua +++ b/advtrains_interlocking/database.lua @@ -2,71 +2,19 @@ -- saving the location of TCB's, their neighbors and their state --[[ -== THIS COMMENT IS PARTIALLY INCORRECT AND OUTDATED! == - -The interlocking system is based on track circuits. -Track circuit breaks must be manually set by the user. Signals must be assigned to track circuit breaks and to a direction(connid). -To simplify the whole system, there is no overlap. -== Trains == -Trains always occupy certain track circuits. These are shown red in the signalbox view (TRAIN occupation entry). -== Database storage == -The things that are actually saved are the Track Circuit Breaks. Each TCB holds a list of the TCBs that are adjacent in each direction. -TC occupation/state is then saved inside each (TCB,Direction) and held in sync across all TCBs adjacent to this one. If something should not be in sync, -all entries are merged to perform the most restrictive setup. -== Traverser function == -To determine and update the list of neighboring TCBs, we need a traverser function. -It will start at one TCB in a specified direction (connid) and use get_adjacent_rail to crawl along the track. When encountering a turnout or a crossing, -it needs to branch(call itself recursively) to find all required TCBs. Those found TCBs are then saved in a list as tuples (TCB,Dir) -In the last step, they exchange their neighbors. -== TC states == -A track circuit does not have a state as such, but has more or less a list of "reservations" -type can be one of these: -TRAIN See Trains obove -ROUTE Route set from a signal, but no train has yet passed that signal. -Not implemented (see note by reversible): OWNED - former ROUTE segments that a train has begun passing (train_id assigned) - - Space behind a train up to the next signal, when a TC is set as REVERSIBLE -Certain TCs can be marked as "allow call-on". -== Route setting: == -Routes are set from a signal (the entry signal) to another signal facing the same direction (the exit signal) -Remember that signals are assigned to a TCB and a connid. -Whenever this is done, the following track circuits are set "reserved" by the train by saving the entry signal's ID: -- all TCs on the direct way of the route - set as ROUTE -Route setting fails whenever any TC that we want to set ROUTE to is already set ROUTE or TRAIN from another signal (except call-on, see below) -Apart from this, we need to set turnouts -- Turnouts on the track are set held as ROUTE -- Turnouts that purpose as flank protection are set held as FLANK (NOTE: left as an idea for later, because it's not clear how to do this properly without an engineer) -Note: In SimSig, it is possible to set a route into an still occupied section on the victoria line sim. (at the depot exit at seven sisters), although - there are still segments set ahead of the first train passing, remaining from another route. - Because our system will be able to remember "requested routes" and set them automatically once ready, this is not necessary here. -== Call-On/Multiple Trains == -It will be necessary to join and split trains using call-on routes. A call-on route may be set when: -- there are no ROUTE reservations -- there are TRAIN reservations only inside TCs that have "allow call-on" set -== TC Properties == -Note: Reversible property will not be implemented, assuming everything as non-rev. -This is sufficient to cover all use cases, and is done this way in reality. - REVERSIBLE - Whether trains are allowed to reverse while on track circuit - This property is supposed to be set for station tracks, where there is a signal at each end, and for sidings. - It should in no case be set for TCs covering turnouts, or for main running lines. - When a TC is not set as reversible, the OWNED status is cleared from the TC right after the train left it, - to allow other trains to pass it. - If it is set reversible, interlocking will keep the OWNED state behind the train up to the next signal, clearing it - as soon as the train passes another signal or enters a non-reversible section. -CALL_ON_ALLOWED - Whether this TC being blocked (TRAIN or ROUTE) does not prevent shunt routes being set through this TC -== More notes == -- It may not be possible to switch turnouts when their TC has any state entry - == Route releasing (TORR) == A train passing through a route happens as follows: Route set from entry to exit signal -Train passes entry signal and enters first TC past the signal --> Route from signal cleared (TCs remain locked) --> ROUTE status of first TC past signal cleared +Train passes entry signal and enters first TS past the signal +-> Route from signal cleared (TSs remain locked) +-> 'route' status of first TS past signal cleared +-> 'route_post' (holding the turnout locks) remains set Train continues along the route. -Whenever train leaves a TC +Whenever train leaves a TS -> Clearing any routes set from this TC outward recursively - see "Reversing problem" -Whenever train enters a TC --> Clear route status from the just entered TC +-> Free turnout locks and clear 'route_post' +Whenever train enters a TS +-> Clear route status from the just entered TC (but not route_post) Note that this prohibits by design that the train clears the route ahead of it. == Reversing Problem == Encountered at the Royston simulation in SimSig. It is solved there by imposing a time limit on the set route. Call-on routes can somehow be set anyway. @@ -89,6 +37,22 @@ Another case of this: The / here is a non-interlocked turnout (to a non-frequently used siding). For some reason, there is no exit node there, so the route is set to the signal at the right end. The train is taking the exit to the siding and frees the TC, without ever having touched the right TC. + + +== Terminology / Variable Names == + +"tcb" : A TCB table (as in track_circuit_breaks) +"tcbs" : One side of a tcb (that is tcb == {[1] = tcbs, [2] = tcbs}) +"sigd" : A table of format {p=<position>, s=<side aka connid>} by which a "tcbs" is uniqely identified. + +== Section Autorepair & Turnout Cache == + +As fundamental part of reworked route programming mechanism, Track Section objects become weak now. They are created and destroyed on demand. +ildb.repair_tcb automatically checks all nearby sections for issues and repairs them automatically. + +Also the database now holds a cache of the turnouts in the section and their position for all possible driving paths. +Every time a repair operation takes place, and on every track edit operation, the affected sections need to have their cache updated. + ]]-- local TRAVERSER_LIMIT = 1000 @@ -111,7 +75,45 @@ advtrains.interlocking.npr_rails = {} function ildb.load(data) if not data then return end if data.tcbs then - track_circuit_breaks = data.tcbs + if data.tcbpts_conversion_applied then + track_circuit_breaks = data.tcbs + else + -- Convert legacy pos_to_string tcbs to new advtrains.encode_pos position strings + for pts, tcb in pairs(data.tcbs) do + local pos = minetest.string_to_pos(pts) + if pos then + -- that was a pos_to_string + local epos = advtrains.encode_pos(pos) + atdebug("ILDB converting TCB position format",pts,"->",epos) + track_circuit_breaks[epos] = tcb + else + -- keep entry, it is already new + track_circuit_breaks[pts] = tcb + end + -- convert the routes.[].locks table keys + for t_side,tcbs in pairs(tcb) do + if tcbs.routes then + for t_rnum,route in pairs(tcbs.routes) do + for t_rsnm,rseg in ipairs(route) do + local locks_n = {} + for lpts,state in pairs(rseg.locks) do + local lpos = minetest.string_to_pos(lpts) + if lpos then + local epos = advtrains.encode_pos(lpos) + atdebug("ILDB converting tcb",pts,"side",t_side,"route",t_route,"lock position format",lpts,"->",epos) + locks_n[epos] = state + else + -- already correct format + locks_n[lpts] = state + end + end + rseg.locks = locks_n + end + end + end + end + end + end end if data.ts then track_sections = data.ts @@ -120,7 +122,23 @@ function ildb.load(data) signal_assignments = data.signalass end if data.rs_locks then - advtrains.interlocking.route.rte_locks = data.rs_locks + if data.tcbpts_conversion_applied then + advtrains.interlocking.route.rte_locks = data.rs_locks + else + advtrains.interlocking.route.rte_locks = {} + for pts, lta in pairs(data.rs_locks) do + local pos = minetest.string_to_pos(pts) + if pos then + -- that was a pos_to_string + local epos = advtrains.encode_pos(pos) + atdebug("ILDB converting Route Lock position format",pts,"->",epos) + advtrains.interlocking.route.rte_locks[epos] = lta + else + -- keep entry, it is already new + advtrains.interlocking.route.rte_locks[pts] = lta + end + end + end end if data.rs_callbacks then advtrains.interlocking.route.rte_callbacks = data.rs_callbacks @@ -176,8 +194,7 @@ function ildb.save() rs_callbacks = advtrains.interlocking.route.rte_callbacks, influence_points = influence_points, npr_rails = advtrains.interlocking.npr_rails, - supposed_aspects = advtrains.interlocking.save_supposed_aspects(), - distant = advtrains.distant.save(), + tcbpts_conversion_applied = true, -- remark that legacy pos conversion has taken place } advtrains.interlocking.signal.save(data) return data @@ -190,6 +207,9 @@ TCB data structure -- This is the "A" side of the TCB [1] = { -- Variant: with adjacent TCs. ts_id = <id> -- ID of the assigned track section + xlink = <other sigd> -- If two sections of track are not physically joined but must function as one TS (e.g. knights move crossing), a bidirectional link can be added with exactly one other TCB. + -- TS search will behave as if these two TCBs were physically connected. + signal = <pos> -- optional: when set, routes can be set from this tcb/direction and signal -- aspect will be set accordingly. routeset = <index in routes> -- Route set from this signal. This is the entry that is cleared once @@ -202,20 +222,54 @@ TCB data structure signal_name = <string> -- The human-readable name of the signal, only for documenting purposes routes = { <route definition> } -- a collection of routes from this signal route_auto = <boolean> -- When set, we will automatically re-set the route (designated by routeset) + + auto_block_signal_mode = <boolean> -- Simplified mode for simple block signals: + -- Signal has only one route which is constantly re-set (route_auto is implied) + -- Supposed to be used when only a single track section is ahead and it directly ends at the next signal + -- UI only offers to enable or disable the signal + -- ARS is implicitly disabled on the signal }, -- This is the "B" side of the TCB [2] = { -- Variant: end of track-circuited area (initial state of TC) ts_id = nil, -- this is the indication for end_of_interlocking - section_free = <boolean>, --this can be set by an exit node via mesecons or atlatc, - -- or from the tc formspec. } } +Route definition +routes = { + [i] = { + -- one table for each track section on the route + -- Note that the section ID is implicitly inferred from the TCB + 1 = { + locks = { -- component locks for this section of the route. + 800080008000 = st + } + next = S[(-23,9,0)/2] -- the start TCB of the next route segment (pointing forward) + } + 2 = { + locks = {} + -- if next is omitted, then there is no final TCB (e.g. a buffer) + } + name = "<the route name>" + ars = { <ARS rule definition table> } + use_rscache = false -- if true, the track section's rs_cache will be used to set locks in addition to the locks table + -- this is disabled for legacy routes, but enabled for all new routes by default + -- Fields used by the autorouter: + ar_end_sigd = <sigd> -- the sigd describing the end of the route. Used for merging route options on recalculation + } +} + Track section [id] = { name = "Some human-readable name" tc_breaks = { <signal specifier>,... } -- Bounding TC's (signal specifiers) - -- Can be direct ends (auto-detected), conflicting routes or TCBs that are too far away from each other + rs_cache = { [startTcbPosEnc] = { [endTcbPosEnc] = { [componentPosEnc] = "state" } } } + -- Saves the turnout states that need to be locked when a route is set from tcb#x to tcb#y + -- e.g. "800080008005" = { "800080007EEA" = { "800080008000" = "st" } } + -- start TCB end TCB switch pos + -- Recalculated on every change via update_rs_cache + -- Note that the tcb side number is not saved because it is unnecessary + route = { origin = <signal>, -- route origin entry = <sigd>, -- supposed train entry point @@ -231,7 +285,9 @@ Track section -- first says whether to clear the routesetting status from the origin signal. -- locks contains the positions where locks are held by this ts. -- 'route' is cleared when train enters the section, while 'route_post' cleared when train leaves section. + trains = {<id>, ...} -- Set whenever a train (or more) reside in this TC + -- Note: The same train ID may be contained in this mapping multiple times, when it has entered the section in two different places. } @@ -244,24 +300,13 @@ signal_assignments = { } ]] +-- Maximum scan length for track iterator +local TS_MAX_SCAN = 1000 --- -function ildb.create_tcb(pos) - local new_tcb = { - [1] = {}, - [2] = {}, - } - local pts = advtrains.roundfloorpts(pos) - if not track_circuit_breaks[pts] then - track_circuit_breaks[pts] = new_tcb - return true - else - return false - end -end +-- basic functions function ildb.get_tcb(pos) - local pts = advtrains.roundfloorpts(pos) + local pts = advtrains.encode_pos(pos) return track_circuit_breaks[pts] end @@ -271,227 +316,614 @@ function ildb.get_tcbs(sigd) return tcb[sigd.s] end - -function ildb.create_ts(sigd) - local tcbs = ildb.get_tcbs(sigd) - local id = advtrains.random_id() - - while track_sections[id] do - id = advtrains.random_id() - end - - track_sections[id] = { - name = "Section "..id, - tc_breaks = { sigd } - } - tcbs.ts_id = id -end - function ildb.get_ts(id) return track_sections[id] end +-- retrieve full tables. Please use only read-only! +function ildb.get_all_tcb() + return track_circuit_breaks +end +function ildb.get_all_ts() + return track_sections +end +function tsrepair_notify(notify_pname, ...) + if notify_pname then + minetest.chat_send_player(notify_pname, advtrains.print_concat_table({"TS Check:",...})) + end +end --- various helper functions handling sigd's -local sigd_equal = advtrains.interlocking.sigd_equal -local function insert_sigd_nodouble(list, sigd) - for idx, cmp in pairs(list) do - if sigd_equal(sigd, cmp) then - return +-- Checks the consistency of the track section at the given position, attempts to autorepair track sections if they are inconsistent +-- There are 2 operation modes: +-- 1: pos is NOT a TCB, tcb_connid MUST be nil +-- 2: pos is a TCB, tcb_connid MUST be given +-- @param pos: the position to start from +-- @param tcb_connid: If provided node is a TCB, the direction in which to search +-- @param notify_pname: the player to notify about reparations +-- Returns: +-- ts_id - the track section that was found +-- nil - No track section exists +function ildb.check_and_repair_ts_at_pos(pos, tcb_connid, notify_pname) + --atdebug("check_and_repair_ts_at_pos", pos, tcb_connid) + -- check prereqs + if ildb.get_tcb(pos) then + if not tcb_connid then error("check_and_repair_ts_at_pos: Startpoint is TCB, must provide tcb_connid!") end + else + --if tcb_connid then error("check_and_repair_ts_at_pos: Startpoint is not TCB, must not provide tcb_connid!") end + -- do not give error here, for some applications do not require it + end + -- STEP 1: Ensure that only one section is at this place + -- get all TCBs adjacent to this + local all_tcbs = ildb.get_all_tcbs_adjacent(pos, tcb_connid) + local first_ts = true + local ts_id + for _,sigd in ipairs(all_tcbs) do + ildb.tcbs_ensure_ts_ref_exists(sigd) + local tcbs_ts_id = sigd.tcbs.ts_id + if first_ts then + -- this one determines + ts_id = tcbs_ts_id + first_ts = false + else + -- these must be the same as the first + if ts_id ~= tcbs_ts_id then + -- inconsistency is found, repair it + --atdebug("check_and_repair_ts_at_pos: Inconsistency is found!") + tsrepair_notify(notify_pname, "Track section inconsistent here, repairing...") + return ildb.repair_ts_merge_all(all_tcbs, false, notify_pname) + -- Step2 check is no longer necessary since we just created that new section + end end end - table.insert(list, sigd) + -- only one found (it is either nil or a ts id) + --atdebug("check_and_repair_ts_at_pos: TS consistent id=",ts_id,"") + if not ts_id then + tsrepair_notify(notify_pname, "No track section found here.") + return + -- All TCBs agreed that there is no section here. + end + + local ts = ildb.get_ts(ts_id) + if not ts then + -- This branch may never be reached, because ildb.tcbs_ensure_ts_ref_exists(sigd) is already supposed to clear out missing sections + error("check_and_repair_ts_at_pos: Resolved to nonexisting section although ildb.tcbs_ensure_ts_ref_exists(sigd) was supposed to prevent this. Panic!") + end + ildb.purge_ts_tcb_refs(ts_id) + -- STEP 2: Ensure that all_tcbs is equal to the track section's TCB list. If there are extra TCBs then the section should be split + -- ildb.tcbs_ensure_ts_ref_exists(sigd) has already make sure that all tcbs are found in the ts's tc_breaks list + -- That means it is sufficient to compare the LENGTHS of both lists, if one is longer then it is inconsistent + if #ts.tc_breaks ~= #all_tcbs then + --atdebug("check_and_repair_ts_at_pos: Partition is found!") + tsrepair_notify(notify_pname, "Track section partition found, repairing...") + return ildb.repair_ts_merge_all(all_tcbs, false, notify_pname) + end + tsrepair_notify(notify_pname, "Found section", ts.name or ts_id, "here.") + return ts_id end - --- This function will actually handle the node that is in connid direction from the node at pos --- so, this needs the conns of the node at pos, since these are already calculated -local function traverser(found_tcbs, pos, conns, connid, count, brk_when_found_n) - local adj_pos, adj_connid, conn_idx, nextrail_y, next_conns = advtrains.get_adjacent_rail(pos, conns, connid, advtrains.all_tracktypes) - if not adj_pos then - --atdebug("Traverser found end-of-track at",pos, connid) - return +-- Helper function to prevent duplicates +local function insert_sigd_if_not_present(tab, sigd) + local found = false + for _, ssigd in ipairs(tab) do + if vector.equals(sigd.p, ssigd.p) and sigd.s==ssigd.s then + found = true + end end - -- look whether there is a TCB here - if #next_conns == 2 then --if not, don't even try! - local tcb = ildb.get_tcb(adj_pos) - if tcb then - -- done with this branch - --atdebug("Traverser found tcb at",adj_pos, adj_connid) - insert_sigd_nodouble(found_tcbs, {p=adj_pos, s=adj_connid}) - return + if not found then + table.insert(tab, sigd) + end + return not found +end + +-- Starting from a position, search all TCBs that can be reached from this position. +-- In a non-faulty setup, all of these should have the same track section assigned. +-- This function does not trigger a repair. +-- @param inipos: the initial position +-- @param inidir: the initial direction, or nil to search in all directions +-- @param per_track_callback: A callback function called with signature (pos, connid, bconnid) for every track encountered +-- Returns: a list of sigd's describing the TCBs found (sigd's point inward): +-- {p=<pos>, s=<side>, tcbs=<ref to tcbs table>} +function ildb.get_all_tcbs_adjacent(inipos, inidir, per_track_callback) + --atdebug("get_all_tcbs_adjacent: inipos",inipos,"inidir",inidir,"") + local found_sigd = {} + local ti = advtrains.get_track_iterator(inipos, inidir, TS_MAX_SCAN, true) + -- if initial start is TCBS and has xlink, need to add that to the TI + local inisi = {p=inipos, s=inidir}; + local initcbs = ildb.get_tcbs(inisi) + if initcbs then + ildb.validate_tcb_xlink(inisi, true) + if initcbs.xlink then + -- adding the tcb will happen when this branch is retrieved again using ti:next_branch() + --atdebug("get_all_tcbs_adjacent: Putting xlink Branch for initial node",initcbs.xlink) + ti:add_branch(initcbs.xlink.p, initcbs.xlink.s) end end - -- recursion abort condition - if count > TRAVERSER_LIMIT then - --atdebug("Traverser hit counter at",adj_pos, adj_connid) - return true + local pos, connid, bconnid, tcb + while ti:has_next_branch() do + pos, connid = ti:next_branch() + --atdebug("get_all_tcbs_adjacent: BRANCH: ",pos, connid) + bconnid = nil + is_branch_start = true + repeat + -- callback + if per_track_callback then + per_track_callback(pos, connid, bconnid) + end + tcb = ildb.get_tcb(pos) + if tcb then + local using_connid = bconnid + -- found a tcb + if is_branch_start then + -- A branch cannot be a TCB, as that would imply that it was a turnout/crossing (illegal) + -- UNLESS: (a) it is the start point or (b) it was added via xlink + -- Then the correct conn to use is connid (pointing forward) + --atdebug("get_all_tcbs_adjacent: Inserting TCB at branch start",pos, connid) + using_connid = connid + end + -- add the sigd of this tcb and a reference to the tcb table in it + --atdebug("get_all_tcbs_adjacent: Found TCB: ",pos, using_connid, "ts=", tcb[using_connid].ts_id) + local si = {p=pos, s=using_connid, tcbs=tcb[using_connid]} + -- if xlink exists, add it now (only if we are not in branch start) + ildb.validate_tcb_xlink(si, true) + if not is_branch_start and si.tcbs.xlink then + -- adding the tcb will happen when this branch is retrieved again using ti:next_branch() + --atdebug("get_all_tcbs_adjacent: Putting xlink Branch",si.tcbs.xlink) + ti:add_branch(si.tcbs.xlink.p, si.tcbs.xlink.s) + end + insert_sigd_if_not_present(found_sigd, si) + if not is_branch_start then + break + end + end + pos, connid, bconnid = ti:next_track() + is_branch_start = false + --atdebug("get_all_tcbs_adjacent: TRACK: ",pos, connid, bconnid) + until not pos end - -- continue traversing - local counter_hit = false - for nconnid, nconn in ipairs(next_conns) do - if adj_connid ~= nconnid then - counter_hit = counter_hit or traverser(found_tcbs, adj_pos, next_conns, nconnid, count + 1, brk_when_found_n) - if brk_when_found_n and #found_tcbs>=brk_when_found_n then - break + return found_sigd +end + +-- Called by frontend functions when multiple tcbs's that logically belong to one section have been determined to have different sections +-- Parameter is the output of ildb.get_all_tcbs_adjacent(pos) +-- Returns the ID of the track section that results after the merge +function ildb.repair_ts_merge_all(all_tcbs, force_create, notify_pname) + --atdebug("repair_ts_merge_all: Instructed to merge sections of following TCBs:") + -- The first loop does the following for each TCBS: + -- a) Store the TS ID in the set of TS to update + -- b) Set the TS ID to nil, so that the TCBS gets removed from the section + local ts_to_update = {} + local ts_name_repo = {} + local any_ts = false + for _,sigd in ipairs(all_tcbs) do + local ts_id = sigd.tcbs.ts_id + --atdebug(sigd, "ts=", ts_id) + if ts_id then + local ts = track_sections[ts_id] + if ts then + any_ts = true + ts_to_update[ts_id] = true + -- if nonstandard name, store this + if ts.name and not string.match(ts.name, "^Section") then + ts_name_repo[#ts_name_repo+1] = ts.name + end end end + sigd.tcbs.ts_id = nil end - return counter_hit + if not any_ts and not force_create then + -- nothing to do at all, just no interlocking. Why were we even called + --atdebug("repair_ts_merge_all: No track section present, will not create a new one") + return nil + end + -- Purge every TS in turn. TS's that are now empty will be deleted. TS's that still have TCBs will be kept + for ts_id, _ in pairs(ts_to_update) do + local remain_ts = ildb.purge_ts_tcb_refs(ts_id) + end + -- Create a new fresh track section with all the TCBs we have in our collection + local new_ts_id, new_ts = ildb.create_ts_from_tcb_list(all_tcbs) + tsrepair_notify(notify_pname, "Created track section",new_ts_id,"from TCBs:", all_tcbs) + return new_ts_id end - - --- Merges the TS with merge_id into root_id and then deletes merge_id -local function merge_ts(root_id, merge_id) - local rts = ildb.get_ts(root_id) - local mts = ildb.get_ts(merge_id) - if not mts then return end -- This may be the case when sync_tcb_neighbors - -- inserts the same id twice. do nothing. - - if not ildb.may_modify_ts(rts) then return false end - if not ildb.may_modify_ts(mts) then return false end - - -- cobble together the list of TCBs - for _, msigd in ipairs(mts.tc_breaks) do - local tcbs = ildb.get_tcbs(msigd) +-- For the specified TS, go through the list of TCBs and purge all TCBs that have no corresponding backreference in their TCBS table. +-- If the track section ends up empty, it is deleted in this process. +-- Should the track section still exist after the purge operation, it is returned. +function ildb.purge_ts_tcb_refs(ts_id) + local ts = track_sections[ts_id] + if not ts then + return nil + end + local has_changed = false + local i = 1 + while ts.tc_breaks[i] do + -- get TCBS + local sigd = ts.tc_breaks[i] + local tcbs = ildb.get_tcbs(sigd) if tcbs then - insert_sigd_nodouble(rts.tc_breaks, msigd) - tcbs.ts_id = root_id + if tcbs.ts_id == ts_id then + -- this one is legit + i = i+1 + else + -- this one is to be purged + --atdebug("purge_ts_tcb_refs(",ts_id,"): purging",sigd,"(backreference = ",tcbs.ts_id,")") + table.remove(ts.tc_breaks, i) + has_changed = true + end + else + -- if not tcbs: was anyway an orphan, remove it + --atdebug("purge_ts_tcb_refs(",ts_id,"): purging",sigd,"(referred nonexisting TCB)") + table.remove(ts.tc_breaks, i) + has_changed = true end - advtrains.interlocking.show_tcb_marker(msigd.p) end - -- done - track_sections[merge_id] = nil + if #ts.tc_breaks == 0 then + -- remove the section completely + --atdebug("purge_ts_tcb_refs(",ts_id,"): after purging, the section is empty, is being deleted") + track_sections[ts_id] = nil + return nil + else + if has_changed then + -- needs to update route cache + ildb.update_rs_cache(ts_id) + end + return ts + end end -local lntrans = { "A", "B" } -local function sigd_to_string(sigd) - return minetest.pos_to_string(sigd.p).." / "..lntrans[sigd.s] +-- For the specified TCBS, make sure that the track section referenced by it +-- (a) exists and +-- (b) has a backreference to this TCBS stored in its tc_breaks list +function ildb.tcbs_ensure_ts_ref_exists(sigd) + local tcbs = sigd.tcbs or ildb.get_tcbs(sigd) + if not tcbs or not tcbs.ts_id then return end + local ts = ildb.get_ts(tcbs.ts_id) + if not ts then + --atdebug("tcbs_ensure_ts_ref_exists(",sigd,"): TS does not exist, setting to nil") + -- TS is deleted, clear own ts id + tcbs.ts_id = nil + return + end + local did_insert = insert_sigd_if_not_present(ts.tc_breaks, {p=sigd.p, s=sigd.s}) + if did_insert then + --atdebug("tcbs_ensure_ts_ref_exists(",sigd,"): TCBS was missing reference in TS",tcbs.ts_id) + ildb.update_rs_cache(tcbs.ts_id) + end end --- Check for near TCBs and connect to their TS if they have one, and syncs their data. -function ildb.sync_tcb_neighbors(pos, connid) - local found_tcbs = { {p = pos, s = connid} } - local node_ok, conns, rhe = advtrains.get_rail_info_at(pos, advtrains.all_tracktypes) - if not node_ok then - atwarn("update_tcb_neighbors but node is NOK: "..minetest.pos_to_string(pos)) - return +function ildb.create_ts_from_tcb_list(sigd_list) + local id = advtrains.random_id(8) + + while track_sections[id] do + id = advtrains.random_id(8) + end + --atdebug("create_ts_from_tcb_list: sigd_list=",sigd_list, "new ID will be ",id) + + local tcbr = {} + -- makes a copy of the sigd list, for use in repair mechanisms where sigd may contain a tcbs field which we dont want + for _, sigd in ipairs(sigd_list) do + table.insert(tcbr, {p=sigd.p, s=sigd.s}) + local tcbs = sigd.tcbs or ildb.get_tcbs(sigd) + if tcbs.ts_id then + error("Trying to create TS with TCBS that is already assigned to other section") + end + tcbs.ts_id = id end - --atdebug("Traversing from ",pos, connid) - local counter_hit = traverser(found_tcbs, pos, conns, connid, 0) + local new_ts = { + tc_breaks = tcbr + } + track_sections[id] = new_ts + -- update the TCB markers + for _, sigd in ipairs(sigd_list) do + advtrains.interlocking.show_tcb_marker(sigd.p) + end - local ts_id - local list_eoi = {} - local list_ok = {} - local list_mismatch = {} - local ts_to_merge = {} - for idx, sigd in pairs(found_tcbs) do - local tcbs = ildb.get_tcbs(sigd) - if not tcbs.ts_id then - --atdebug("Sync: put",sigd_to_string(sigd),"into list_eoi") - table.insert(list_eoi, sigd) - elseif not ts_id and tcbs.ts_id then - if not ildb.get_ts(tcbs.ts_id) then - atwarn("Track section database is inconsistent, there's no TS with ID=",tcbs.ts_id) - tcbs.ts_id = nil - table.insert(list_eoi, sigd) + ildb.update_rs_cache(id) + return id, new_ts +end + +-- RS CACHE -- + +--[[ +node_from_to_list - cache of from-to connid mappings and their associated state. +Acts like a cache, built on demand by ildb.get_possible_out_connids(nodename) +node_name = { + from_connid = { + to_connid = state + } +} +]] +local node_from_to_state_cache = {} + +function ildb.get_possible_out_connids(node_name, in_connid) + if not node_from_to_state_cache[node_name] then + node_from_to_state_cache[node_name] = {} + end + local nt = node_from_to_state_cache[node_name] + if not nt[in_connid] then + local ta = {} + --atdebug("Node From/To State Cache: Caching for ",node_name,"connid",in_connid) + local ndef = minetest.registered_nodes[node_name] + if ndef.advtrains.node_state_map then + for state, tnode in pairs(ndef.advtrains.node_state_map) do + local tndef = minetest.registered_nodes[tnode] + -- verify that the conns table is identical - this is purely to catch setup errors! + if not tndef.at_conns or not tndef.at_conn_map then + --atdebug("ndef:",ndef,", tndef:",tndef) + error("In AT setup for node "..tnode..": Node set as state "..state.." of "..node_name.." in state_map, but is missing at_conns/at_conn_map!") + end + if #ndef.at_conns ~= #tndef.at_conns then + --atdebug("ndef:",ndef,", tndef:",tndef) + error("In AT setup for node "..tnode..": Conns table does not match that of "..node_name.." (of which this is state "..state..")") + end + for connid=1,#ndef.at_conns do + if ndef.at_conns[connid].c ~= tndef.at_conns[connid].c then + --atdebug("ndef:",ndef,", tndef:",tndef) + error("In AT setup for node "..tnode..": Conns table does not match that of "..node_name.." (of which this is state "..state..")") + end + end + -- do the actual caching by looking at the conn_map + local target_connid = tndef.at_conn_map[in_connid] + if ta[target_connid] then + -- Select the variant for which the other way would back-connect. This way, turnouts will switch to the appropriate branch if the train joins + local have_back_conn = (tndef.at_conn_map[target_connid])==in_connid + --atdebug("Found second state mapping",in_connid,"-",target_connid,"have_back_conn=",have_back_conn) + if have_back_conn then + --atdebug("Overwriting",in_connid,"-",target_connid,"=",state) + ta[target_connid] = state + end + else + --atdebug("Setting",in_connid,"-",target_connid,"=",state) + ta[target_connid] = state + end + end + else + error("Node From/To State Cache: "..node_name.." doesn't have a state map, is not a switchable track! Panic!") + end + nt[in_connid] = ta + end + return nt[in_connid] +end + +local function recursively_find_routes(s_pos, s_connid, locks_found, result_table, scan_limit) + --atdebug("Recursively restarting at ",s_pos, s_connid, "limit left", scan_limit) + local ti = advtrains.get_track_iterator(s_pos, s_connid, scan_limit, false) + local pos, connid, bconnid = ti:next_branch() + pos, connid, bconnid = ti:next_track()-- step once to get ahead of previous turnout + local last_pos + repeat + local node = advtrains.ndb.get_node_or_nil(pos) + --atdebug("Walk ",pos, "nodename", node.name, "entering at conn",bconnid) + local ndef = minetest.registered_nodes[node.name] + if ndef.advtrains and ndef.advtrains.node_state_map then + -- Stop, this is a switchable node. Find out which conns we can go at + --atdebug("Found turnout ",pos, "nodename", node.name, "entering at conn",bconnid) + local pts = advtrains.encode_pos(pos) + if locks_found[pts] then + -- we've been here before. Stop + --atdebug("Was already seen! returning") + return + end + local out_conns = ildb.get_possible_out_connids(node.name, bconnid) + for oconnid, state in pairs(out_conns) do + --atdebug("Going in direction",oconnid,"state",state) + locks_found[pts] = state + recursively_find_routes(pos, oconnid, locks_found, result_table, ti.limit) + locks_found[pts] = nil + end + return + end + --otherwise, this might be a tcb + local tcb = ildb.get_tcb(pos) + if tcb then + -- we found a tcb, store the current locks in the result_table + local end_pkey = advtrains.encode_pos(pos) + --atdebug("Found end TCB", pos, end_pkey,", returning") + if result_table[end_pkey] then + atwarn("While caching track section routing, found multiple route paths within same track section. Only first one found will be used") else - --atdebug("Sync: put",sigd_to_string(sigd),"into list_ok") - ts_id = tcbs.ts_id - table.insert(list_ok, sigd) + result_table[end_pkey] = table.copy(locks_found) end - elseif ts_id and tcbs.ts_id and tcbs.ts_id ~= ts_id then - atwarn("Track section database is inconsistent, sections share track!") - atwarn("Merging",tcbs.ts_id,"into",ts_id,".") - table.insert(list_mismatch, sigd) - table.insert(ts_to_merge, tcbs.ts_id) + return end + -- Go forward + last_pos = pos + pos, connid, bconnid = ti:next_track() + until not pos -- this stops the loop when either the track end is reached or the limit is hit + --atdebug("recursively_find_routes: Reached track end or limit at", last_pos, ". This path is not saved, returning") +end + +-- Updates the turnout cache of the given track section +function ildb.update_rs_cache(ts_id) + local ts = ildb.get_ts(ts_id) + if not ts then + error("Update TS Cache called with nonexisting ts_id "..(ts_id or "nil")) end - if ts_id then - local ts = ildb.get_ts(ts_id) - for _, sigd in ipairs(list_eoi) do - local tcbs = ildb.get_tcbs(sigd) - tcbs.ts_id = ts_id - table.insert(ts.tc_breaks, sigd) - advtrains.interlocking.show_tcb_marker(sigd.p) + local rscache = {} + --atdebug("== Running update_rs_cache for ",ts_id) + -- start on every of the TS's TCBs, walk the track forward and store locks along the way + for start_tcbi, start_tcbs in ipairs(ts.tc_breaks) do + start_pkey = advtrains.encode_pos(start_tcbs.p) + rscache[start_pkey] = {} + --atdebug("Starting for ",start_tcbi, start_tcbs) + local locks_found = {} + local result_table = {} + recursively_find_routes(start_tcbs.p, start_tcbs.s, locks_found, result_table, TS_MAX_SCAN) + -- now result_table contains found route locks. Match them with the other TCBs we have in this section + for end_tcbi, end_tcbs in ipairs(ts.tc_breaks) do + if end_tcbi ~= start_tcbi then + end_pkey = advtrains.encode_pos(end_tcbs.p) + if result_table[end_pkey] then + --atdebug("Set RSCache entry",end_pkey.."-"..end_pkey,"=",result_table[end_pkey]) + rscache[start_pkey][end_pkey] = result_table[end_pkey] + result_table[end_pkey] = nil + end + end end - for _, mts in ipairs(ts_to_merge) do - merge_ts(ts_id, mts) + -- warn about superfluous entry + for sup_end_pkey, sup_entry in pairs(result_table) do + --atwarn("In update_rs_cache for section",ts_id,"found superfluous endpoint",sup_end_pkey,"->",sup_entry) end end + ts.rs_cache = rscache + --atdebug("== Done update_rs_cache for ",ts_id, "result:",rscache) end -function ildb.link_track_sections(merge_id, root_id) - if merge_id == root_id then - return + +--- DB API functions + +local lntrans = { "A", "B" } +function ildb.sigd_to_string(sigd) + return minetest.pos_to_string(sigd.p).." / "..lntrans[sigd.s] +end + +-- Create a new TCB at the position and update/repair the adjoining sections +function ildb.create_tcb_at(pos) + --atdebug("create_tcb_at",pos) + local pts = advtrains.encode_pos(pos) + track_circuit_breaks[pts] = {[1] = {}, [2] = {}} + local all_tcbs_1 = ildb.get_all_tcbs_adjacent(pos, 1) + --atdebug("TCBs on A side",all_tcbs_1) + local all_tcbs_2 = ildb.get_all_tcbs_adjacent(pos, 2) + --atdebug("TCBs on B side",all_tcbs_2) + -- perform TS repair + ildb.repair_ts_merge_all(all_tcbs_1, false) + ildb.repair_ts_merge_all(all_tcbs_2, false) +end + +-- Remove TCB at the position and update/repair the now joined section +function ildb.remove_tcb_at(pos) + --atdebug("remove_tcb_at",pos) + local pts = advtrains.encode_pos(pos) + local old_tcb = track_circuit_breaks[pts] + track_circuit_breaks[pts] = nil + -- purge the track sections adjacent + if old_tcb[1].ts_id then + ildb.purge_ts_tcb_refs(old_tcb[1].ts_id) end - merge_ts(root_id, merge_id) + if old_tcb[2].ts_id then + ildb.purge_ts_tcb_refs(old_tcb[2].ts_id) + end + -- update xlink partners + if old_tcb[1].xlink then + ildb.validate_tcb_xlink(old_tcb[1].xlink) + end + if old_tcb[2].xlink then + ildb.validate_tcb_xlink(old_tcb[2].xlink) + end + advtrains.interlocking.remove_tcb_marker(pos) + -- If needed, merge the track sections here + ildb.check_and_repair_ts_at_pos(pos, nil) + return true end -function ildb.remove_from_interlocking(sigd) - local tcbs = ildb.get_tcbs(sigd) - if not ildb.may_modify_tcbs(tcbs) then return false end - - if tcbs.ts_id then - local tsid = tcbs.ts_id - local ts = ildb.get_ts(tsid) - if not ts then - tcbs.ts_id = nil - return true +-- Xlink: Connecting not-physically-connected sections handling + +-- Ensures that the xlink of this tcbs is bidirectional +function ildb.validate_tcb_xlink(sigd, suppress_repairs) + local tcbs = sigd.tcbs or ildb.get_tcbs(sigd) + local osigd = tcbs.xlink + if not osigd then return end + local otcbs = ildb.get_tcbs(tcbs.xlink) + if not otcbs then + --atdebug("validate_tcb_xlink",sigd,": Link partner ",osigd,"orphaned") + tcbs.xlink = nil + if not suppress_repairs then + ildb.check_and_repair_ts_at_pos(sigd.p, sigd.s) end - - -- remove entry from the list - local idx = 1 - while idx <= #ts.tc_breaks do - local cmp = ts.tc_breaks[idx] - if sigd_equal(sigd, cmp) then - table.remove(ts.tc_breaks, idx) - else - idx = idx + 1 + return + end + if otcbs.xlink then + if not vector.equals(otcbs.xlink.p, sigd.p) or otcbs.xlink.s~=sigd.s then + --atdebug("validate_tcb_xlink",sigd,": Link partner ",osigd,"backreferencing to someone else (namely",otcbs.xlink,") clearing it") + tcbs.xlink = nil + if not suppress_repairs then + ildb.check_and_repair_ts_at_pos(sigd.p, sigd.s) + --atdebug("validate_tcb_xlink",sigd,": Link partner ",osigd," was backreferencing to someone else, now updating that") + ildb.validate_tcb_xlink(osigd) end end - tcbs.ts_id = nil - - --ildb.sync_tcb_neighbors(sigd.p, sigd.s) - - if #ts.tc_breaks == 0 then - track_sections[tsid] = nil + else + --atdebug("validate_tcb_xlink",sigd,": Link partner ",osigd,"wasn't backreferencing, clearing it") + tcbs.xlink = nil + if not suppress_repairs then + ildb.check_and_repair_ts_at_pos(sigd.p, sigd.s) end end - advtrains.interlocking.show_tcb_marker(sigd.p) - if tcbs.signal then - return false - end - return true end -function ildb.remove_tcb(pos) - local pts = advtrains.roundfloorpts(pos) - if not track_circuit_breaks[pts] then - return true --FIX: not an error, because tcb is already removed +function ildb.add_tcb_xlink(sigd1, sigd2) + --("add_tcb_xlink",sigd1, sigd2) + local tcbs1 = sigd1.tcbs or ildb.get_tcbs(sigd1) + local tcbs2 = sigd2.tcbs or ildb.get_tcbs(sigd2) + if vector.equals(sigd1.p, sigd2.p) then + --atdebug("add_tcb_xlink Cannot xlink with same TCB") + return end - for connid=1,2 do - if not ildb.remove_from_interlocking({p=pos, s=connid}) then - return false - end + if not tcbs1 or not tcbs2 then + --atdebug("add_tcb_xlink TCBS doesnt exist") + return end - track_circuit_breaks[pts] = nil - return true + if tcbs1.xlink or tcbs2.xlink then + --atdebug("add_tcb_xlink One already linked") + return + end + -- apply link + tcbs1.xlink = {p=sigd2.p, s=sigd2.s} + tcbs2.xlink = {p=sigd1.p, s=sigd1.s} + -- update section. It should be sufficient to call update only once because the TCBs are linked anyway now + ildb.check_and_repair_ts_at_pos(sigd1.p, sigd1.s) end -function ildb.dissolve_ts(ts_id) - local ts = ildb.get_ts(ts_id) - if not ildb.may_modify_ts(ts) then return false end - local tcbr = advtrains.merge_tables(ts.tc_breaks) - for _,sigd in ipairs(tcbr) do - ildb.remove_from_interlocking(sigd) +function ildb.remove_tcb_xlink(sigd) + --atdebug("remove_tcb_xlink",sigd) + -- Validate first. If Xlink is gone already then, nothing to do + ildb.validate_tcb_xlink(sigd) + -- Checking all of these already done by validate + local tcbs = sigd.tcbs or ildb.get_tcbs(sigd) + local osigd = tcbs.xlink + if not osigd then + -- validate already cleared us + --atdebug("remove_tcb_xlink: Already gone by validate") + return end - -- Note: ts gets removed in the moment of the removal of the last TCB. - return true + local otcbs = ildb.get_tcbs(tcbs.xlink) + -- clear it + otcbs.xlink = nil + tcbs.xlink = nil + -- Update section for ourself and the other one + ildb.check_and_repair_ts_at_pos(sigd.p, sigd.s) + ildb.check_and_repair_ts_at_pos(osigd.p, osigd.s) +end + +function ildb.create_ts_from_tcbs(sigd) + --atdebug("create_ts_from_tcbs",sigd) + local all_tcbs = ildb.get_all_tcbs_adjacent(sigd.p, sigd.s) + ildb.repair_ts_merge_all(all_tcbs, true) +end + +-- Remove the given track section, leaving its TCBs with no section assigned +function ildb.remove_ts(ts_id) + --atdebug("remove_ts",ts_id) + local ts = track_sections[ts_id] + if not ts then + error("remove_ts: "..ts_id.." doesn't exist") + end + while ts.tc_breaks[i] do + -- get TCBS + local sigd = ts.tc_breaks[i] + local tcbs = ildb.get_tcbs(sigd) + if tcbs then + --atdebug("cleared TCB",sigd) + tcbs.ts_id = nil + else + --atdebug("orphan TCB",sigd) + end + i = i+1 + end + track_sections[ts_id] = nil end -- Returns true if it is allowed to modify any property of a track section, such as @@ -516,38 +948,8 @@ function ildb.may_modify_tcbs(tcbs) return true end --- Utilize the traverser to find the track section at the specified position --- Returns: --- ts_id, origin - the first found ts and the sigd of the found tcb --- nil - there were no TCBs in TRAVERSER_MAX range of the position --- false - the first found TCB stated End-Of-Interlocking, or track ends were reached -function ildb.get_ts_at_pos(pos) - local node_ok, conns, rhe = advtrains.get_rail_info_at(pos, advtrains.all_tracktypes) - if not node_ok then - error("get_ts_at_pos but node is NOK: "..minetest.pos_to_string(pos)) - end - local limit_hit = false - local found_tcbs = {} - for connid, conn in ipairs(conns) do -- Note: a breadth-first-search would be better for performance - limit_hit = limit_hit or traverser(found_tcbs, pos, conns, connid, 0, 1) - if #found_tcbs >= 1 then - local tcbs = ildb.get_tcbs(found_tcbs[1]) - local ts - if tcbs.ts_id then - return tcbs.ts_id, found_tcbs[1] - else - return false - end - end - end - if limit_hit then - -- there was at least one limit hit - return nil - else - -- all traverser ends were track ends - return false - end -end + +-- Signals/IP -- -- returns the sigd the signal at pos belongs to, if this is known @@ -604,7 +1006,7 @@ end function ildb.get_ip_signal_asp(pts, connid) local p = ildb.get_ip_signal(pts, connid) if p then - local asp = advtrains.interlocking.signal_get_aspect(p) + local asp = advtrains.interlocking.signal.get_aspect_info(p) if not asp then atlog("Clearing orphaned signal influence point", pts, "/", connid) ildb.clear_ip_signal(pts, connid) |