aboutsummaryrefslogtreecommitdiff
path: root/advtrains_interlocking/database.lua
diff options
context:
space:
mode:
Diffstat (limited to 'advtrains_interlocking/database.lua')
-rw-r--r--advtrains_interlocking/database.lua213
1 files changed, 163 insertions, 50 deletions
diff --git a/advtrains_interlocking/database.lua b/advtrains_interlocking/database.lua
index e318dd2..b4932ee 100644
--- a/advtrains_interlocking/database.lua
+++ b/advtrains_interlocking/database.lua
@@ -93,13 +93,20 @@ local TRAVERSER_LIMIT = 100
local ildb = {}
local track_circuit_breaks = {}
+local track_sections = {}
function ildb.load(data)
-
+ if not data then return end
+ if data.tcbs then
+ track_circuit_breaks = data.tcbs
+ end
+ if data.ts then
+ track_sections = data.ts
+ end
end
function ildb.save()
- return {}
+ return {tcbs = track_circuit_breaks, ts=track_sections}
end
--
@@ -107,17 +114,7 @@ end
TCB data structure
{
[1] = { -- Variant: with adjacent TCs.
- == Synchronized properties == Apply to the whole TC
- adjacent = { <signal specifier>,... } -- Adjacent TCBs, forms a TC with these
- conflict = { <signal specifier>,... } -- Conflicting TC's (chosen as a representative TCB member)
- -- Used e.g. for crossing rails that do not have nodes in common (like it's currently done)
- incomplete = <boolean> -- Set when the recursion counter hit during traverse. Probably needs to add
- -- another tcb at some far-away place
- route = {origin = <signal>, in_dir = <boolean>}
- -- Set whenever a route has been set through this TC. It saves the origin tcb id and side
- -- (=the origin signal). in_dir is set when the train will enter the TC from this side
-
- == Unsynchronized properties == Apply only to this side of the TC
+ ts_id = <id> -- ID of the assigned track section
signal = <pos> -- optional: when set, routes can be set from this tcb/direction and signal
-- aspect will be set accordingly.
routetar = <signal> -- Route set from this signal. This is the entry that is cleared once
@@ -128,12 +125,25 @@ TCB data structure
-- is set true, clearing the signal
},
[2] = { -- Variant: end of track-circuited area (initial state of TC)
- end_of_interlocking = true,
+ 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.
}
}
-Signal specifier (a pair of TCB/Side):
+
+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
+ route = {origin = <signal>, from_tcb = <index>}
+ -- Set whenever a route has been set through this TC. It saves the origin tcb id and side
+ -- (=the origin signal). index is the TCB of the route origin
+ trains = {<id>, ...} -- Set whenever a train (or more) reside in this TC
+}
+
+
+Signal specifier (sigd) (a pair of TCB/Side):
{p = <pos>, s = <1/2>}
]]
@@ -141,8 +151,8 @@ Signal specifier (a pair of TCB/Side):
--
function ildb.create_tcb(pos)
local new_tcb = {
- [1] = {end_of_interlocking = true},
- [2] = {end_of_interlocking = true},
+ [1] = {},
+ [2] = {},
}
local pts = advtrains.roundfloorpts(pos)
track_circuit_breaks[pts] = new_tcb
@@ -153,6 +163,48 @@ function ildb.get_tcb(pos)
return track_circuit_breaks[pts]
end
+function ildb.get_tcbs(sigd)
+ local tcb = ildb.get_tcb(sigd.p)
+ if not tcb then return nil end
+ 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
+
+
+
+-- various helper functions handling sigd's
+local function sigd_equal(sigd, cmp)
+ return vector.equals(sigd.p, cmp.p) and sigd.s==cmp.s
+end
+local function insert_sigd_nodouble(list, sigd)
+ for idx, cmp in pairs(list) do
+ if sigd_equal(sigd, cmp) then
+ return
+ end
+ end
+ table.insert(list, sigd)
+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)
@@ -166,13 +218,14 @@ local function traverser(found_tcbs, pos, conns, connid, count)
local tcb = ildb.get_tcb(adj_pos)
if tcb then
-- done with this branch
- table.insert(found_tcbs, {p=adj_pos, s=adj_connid})
+ atdebug("Traverser found tcb at",adj_pos, adj_connid)
+ insert_sigd_nodouble(found_tcbs, {p=adj_pos, s=adj_connid})
return
end
end
-- recursion abort condition
if count > TRAVERSER_LIMIT then
- atdebug("Traverser hit counter at",adj_pos, adj_connid,"found tcb's:",found_tcbs)
+ atdebug("Traverser hit counter at",adj_pos, adj_connid)
return true
end
-- continue traversing
@@ -185,62 +238,122 @@ local function traverser(found_tcbs, pos, conns, connid, count)
return counter_hit
end
-local function sigd_equal(sigd, cmp)
- return vector.equals(sigd.p, cmp.p) and sigd.s==cmp.s
-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)
+
+ -- cobble together the list of TCBs
+ for _, msigd in ipairs(mts.tc_breaks) do
+ local tcbs = ildb.get_tcbs(msigd)
+ if tcbs then
+ insert_sigd_nodouble(rts.tc_breaks, msigd)
+ tcbs.ts_id = root_id
+ end
+ end
+ -- done
+ track_sections[merge_id] = nil
+end
+-- TODO temporary
+local lntrans = { "A", "B" }
+local function sigd_to_string(sigd)
+ return minetest.pos_to_string(sigd.p).." / "..lntrans[sigd.s]
+end
--- Updates the neighbors of this TCB using the traverser function (see comments above)
--- returns true if the traverser hit the counter, which means that there could be another
--- TCB outside of the traversed range.
-function ildb.update_tcb_neighbors(pos, connid)
+-- 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
error("update_tcb_neighbors but node is NOK: "..minetest.pos_to_string(pos))
end
+ atdebug("Traversing from ",pos, connid)
local counter_hit = traverser(found_tcbs, pos, conns, connid, 0, hit_counter)
+ 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 tcb = ildb.get_tcb(sigd.p)
- local tcbs = tcb[sigd.s]
-
- tcbs.end_of_interlocking = nil
- tcbs.incomplete = counter_hit
- tcbs.adjacent = {}
-
- for idx2, other_sigd in pairs(found_tcbs) do
- if idx~=idx2 then
- ildb.add_adjacent(tcbs, sigd.p, sigd.s, other_sigd)
+ 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)
+ else
+ atdebug("Sync: put",sigd_to_string(sigd),"into list_ok")
+ ts_id = tcbs.ts_id
+ table.insert(list_ok, sigd)
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)
+ end
+ 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)
+ end
+ for _, mts in ipairs(ts_to_merge) do
+ merge_ts(ts_id, mts)
end
end
-
- return hit_counter
end
--- Add the adjacency entry into the tcbs, but without duplicating it
--- and without adding a self-reference
-function ildb.add_adjacent(tcbs, this_pos, this_connid, sigd)
- if sigd_equal(sigd, {p=this_pos, s=this_connid}) then
+function ildb.link_track_sections(merge_id, root_id)
+ if merge_id == root_id then
return
end
- tcbs.end_of_interlocking = nil
- if not tcbs.adjacent then
- tcbs.adjacent = {}
- end
- for idx, cmp in pairs(tcbs.adjacent) do
- if sigd_equal(sigd, cmp) then
+ merge_ts(root_id, merge_id)
+end
+
+function ildb.remove_from_interlocking(sigd)
+ local tcbs = ildb.get_tcbs(sigd)
+ 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
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
+ end
+ end
+ tcbs.ts_id = nil
+
+ ildb.sync_tcb_neighbors(sigd.p, sigd.s)
+
+ if #ts.tc_breaks == 0 then
+ track_sections[tsid] = nil
+ end
end
- table.insert(tcbs.adjacent, sigd)
end
+
+
advtrains.interlocking.db = ildb