From 885e43e42a6225c6998105b2cb40fec11a41edcc Mon Sep 17 00:00:00 2001
From: autocommitter <autocommitter@linux-forks.de>
Date: Tue, 31 Dec 2024 00:00:00 +0100
Subject: State at 2024-12-31

---
 far/init_code.lua           | 531 ++++++++++++++++++++++++++++++++++++++++++++
 far/nodes/(1753,8,1570).lua |  16 ++
 far/nodes/(1755,8,1570).lua |   9 -
 3 files changed, 547 insertions(+), 9 deletions(-)
 create mode 100644 far/nodes/(1753,8,1570).lua
 delete mode 100644 far/nodes/(1755,8,1570).lua

diff --git a/far/init_code.lua b/far/init_code.lua
index e6fbcb5..15dfbf8 100644
--- a/far/init_code.lua
+++ b/far/init_code.lua
@@ -56,6 +56,10 @@ F.send_route = function(passive_name, route, show_print)
   return return_value
 end
 
+--[[
+F.save_train(POS(26201,24,1417), "east")
+]]
+
 F.save_train = function(pos, direction)
   if event.train then
     if not atc_id then return end
@@ -214,3 +218,530 @@ F.slow_train_down = function(id)
     F.print("Train ID " .. id .. " is slowed down to B1")
   end
 end
+
+-- init code for FAR timetable env
+
+-- stop, scheduled departure every
+-- d_int: Departure every n seconds (epoch modulo)
+-- d_off: Departure time offset
+function F.stop_sd(st_name, doors, departcommand, minstoptime, d_int, d_off)
+  if event.train then
+    local timenow = os.time()
+    local timerdy = timenow + minstoptime
+    local wait = d_int - ((timerdy-d_off) % d_int)
+   local waitcorr = math.floor(wait*0.66)
+    digiline_send("monitor", "Departure scheduled for: | "..os.date("%H:%M:%S", timenow+wait))
+    atc_send("B0 W O"..doors.." D"..waitcorr.." OCD1"..departcommand)
+  else
+    local timenow = os.time()
+    digiline_send("monitor", "Time: "..os.date("%H:%M:%S", timenow))
+  end
+end
+
+function F.stop_sd_sched(st_name, doors, departcommand, minstoptime, d_int, d_off)
+  depart = false
+  if event.train then
+    local time_now = rwt.now()
+    local next_dep_time = rwt.next_rpt(rwt.add(time_now, minstoptime), d_int, d_off)
+    digiline_send("monitor", "Departure scheduled for: | "..rwt.to_string(next_dep_time, true))
+    atc_set_text_inside(st_name.."\nDeparture: "..rwt.to_string(next_dep_time, true))
+    atc_send("B0 W O"..doors)
+    schedule(next_dep_time, "depart")
+  elseif event.schedule then
+    atc_send("OCD1"..departcommand)
+    digiline_send("monitor", "Last Departure: | "..rwt.to_string(rwt.now(), true))
+    atc_set_text_inside("")
+    depart = true
+  end
+end
+
+function F.timedisplay()
+  digiline_send("time", "Time: | "..rwt.to_string(rwt.now(),true).." | "..os.date("%H:%M:%S"))
+  schedule(rwt.next_rpt(rwt.now(),5,0), "")
+end
+
+-- Stat counter and timetaking utilities
+-- Stat from subway
+F.stat=function(line, init)
+  -- statistics
+  -- init
+  if init then
+    reftrain = atc_id
+    a_tbt = 30
+    a_tbtmax = 30
+    a_rtt = 500
+    a_not = 0
+    c_not = 0
+    c_tbtmax = 0
+    time_lt = os.time()
+    time_rt=os.time()
+  end
+  if not a_tbtmax then a_tbtmax = 30 end
+  if not c_tbtmax then c_tbtmax = 0 end
+  --real code
+  if event.train then
+    local time = os.time()
+    c_not = c_not + 1
+    a_tbt = (a_tbt + (time - time_lt)) / 2
+    c_tbtmax = math.max(c_tbtmax, (time - time_lt))
+    if atc_id == reftrain then
+      a_rtt = (a_rtt*0.2 + (time - time_rt)*0.8)
+      a_not = c_not
+      c_not = 0
+      a_tbtmax = (a_tbtmax + c_tbtmax) / 2
+      c_tbtmax = 0
+    end
+    digiline_send("stats", "Stat: "..line..
+      " NoT:"..a_not.."("..c_not..")"..
+      " TbT:"..math.floor(a_tbt).."("..(time-time_lt)..")"..
+      " Tmx:"..math.floor(a_tbtmax).."("..c_tbtmax..")"..
+      " R:"..math.floor(a_rtt).."("..(time - time_rt)..")"
+      )
+    time_lt = time
+    if atc_id == reftrain then
+      time_rt = time
+    end
+  end
+end
+
+S.timetake = {}
+function F.timetake_start(ttname)
+  if not atc_id then return end
+  local nouw = rwt.to_secs(rwt.now())
+  if not S.timetake[ttname] then
+    S.timetake[ttname] = {}
+  end
+  S.timetake[ttname][atc_id] = nouw
+end
+
+--L100
+function F.timetake_end(ttname)
+  if not atc_id then return end
+  if not S.timetake[ttname] or not S.timetake[ttname][atc_id] then
+    digiline_send("timetake", "No start time for "..atc_id)
+    return
+  end
+  local first = S.timetake[ttname][atc_id]
+  local nouw = rwt.to_secs(rwt.now())
+  local tdiff = nouw - first
+  local cavg = S.timetake[ttname].avg
+  local cmax = S.timetake[ttname].max
+  local cmin = S.timetake[ttname].min
+  if cavg and cmax and cmin then
+    S.timetake[ttname].avg = tdiff*0.1 + cavg*0.9
+    S.timetake[ttname].min = math.min(tdiff, cmin)
+    S.timetake[ttname].max = math.max(tdiff, cmax)
+  else
+    S.timetake[ttname].avg = tdiff
+    S.timetake[ttname].min = tdiff
+    S.timetake[ttname].max = tdiff
+  end
+  digiline_send("timetake", ttname..
+    " this:"..tdiff..
+    " min:"..math.floor(S.timetake[ttname].min)..
+    " avg:"..math.floor(S.timetake[ttname].avg)..
+    " max:"..math.floor(S.timetake[ttname].max)
+    )
+end
+
+--== Timetable prototype (TTP) ===
+--[[ table structures:
+F.ttp - static timetable data - see below
+S.ttp[tt_name] = { - dynamic tt data
+  recording_train = <id of the train that is recording travel times, or nil>
+  travel_times = {
+    <station name> = <time in seconds from initial departure at first station of the line to departure at this station>
+  }
+  station_order = { <station 1>, <station 2>...}
+}
+S.ttt[train_id] = { - trains
+      timetable = <timetable ID that the train is currently using>,
+      initial_dep = <departure at first station of the line>,
+      location = <Station where the train was last seen>,
+      desired_dep = <Departure time as in timetable>,
+      planned_dep = <real departure time calculated as the train reaches station>,
+      actual_dep = <actual departure time at last station. is nil while train is stopped>,
+      last_delay = <last known delay of the train - calculated every departure>,
+    }
+}
+]]
+
+local STOP_TIME = 10
+local STOPCMD="B0WO"
+local DEPCMD="A1OCD1SM"
+local RDEPCMD="RA1OCD1SM"
+local DYNAMIC_THR = 10
+local DYNAMIC_EN = false
+
+if not S.ttp then S.ttp = {} end
+if not S.ttt then S.ttt = {} end
+F.ttp={
+  FAR_E = {
+    outside_text = "[FAR] Fareast End\nvia Halfway, Bayonne, Fucking",
+    inside_line_desc = "FAR to Fareast End",
+    stn_display = "FAR Fareast End",
+  },
+  FAR_W = {
+    outside_text = "[FAR] Salt Factory\nvia Fucking,  Bayonne, Halfway",
+    inside_line_desc = "FAR to Salt Factory",
+    stn_display = "FAR Salt Factory",
+  },
+}
+
+--[[
+Timetable entry point. The train finalizes its last timetable and
+registers itself on the given timetable instance. It departs at the next time slot
+(given by interval and offset).
+F.ttp_begin({
+ stn = "Warmoneaye", -- station name
+ tt = "CFE_S", -- timetable ID
+ depint = "05;00", --departure slot interval
+ depoff = "00;00", --departure slot offset
+ doorside = "L",
+ reverse = true,
+ only_lines = nil, --if given a table, only trains where only_lines[get_line()] is true are considered
+ force_tt_reset = false, -- force reset of travel times for this timetable
+})
+]]
+-- Make train depart at the next time slot, and save its start time
+function F.ttp_begin(p)
+  __approach_callback_mode = 1
+
+  if not F.ttp[p.tt] then error("No TT instance "..p.tt) end
+  if not atc_id then
+    print(p.stn,"missing train!",event)
+    return
+  end
+  if not atc_arrow then return end
+  if p.only_lines and not p.only_lines[get_line()] then return end
+  if not S.ttp[p.tt] then S.ttp[p.tt] = {} end
+  local tti = S.ttp[p.tt]
+  --L150
+  if event.approach and not event.has_entered then
+    -- make the train stop
+    atc_set_ars_disable(true)
+    atc_set_lzb_tsr(2)
+    atc_set_text_inside("Next stop: "..p.stn.."\nTerminal Station.\nThis train continues as "..F.ttp[p.tt].inside_line_desc)
+  end
+  if event.train then
+    -- train arrived, planning departure
+    atc_send(STOPCMD .. p.doorside)
+
+    local time_now = rwt.now()
+    -- Train might have had another TT before, do the cleanup from ttp_end here.
+    local trno = S.ttt[atc_id]
+    if trno then
+      local ttio = S.ttp[trno.timetable]
+      if ttio.recording_train == atc_id then
+        ttio.travel_times[p.stn] = rwt.diff(trno.initial_dep, time_now)
+        ttio.station_order[#ttio.station_order+1] = p.stn
+        print(atc_id,"for",p.tt,"at",p.stn,"-> travel time",rwt.to_string(ttio.travel_times[p.stn]),"-route end")
+      end
+    end
+
+    local next_dep_time = rwt.next_rpt(rwt.add(time_now, 10), p.depint, p.depoff)
+    schedule(next_dep_time, "departure")
+    S.ttt[atc_id] = {
+      timetable = p.tt,
+      initial_dep = next_dep_time,
+      location = p.stn,
+      desired_dep = next_dep_time,
+      planned_dep = next_dep_time,
+      last_delay = 0,
+    }
+    -- if no travel times are available yet, set this train as recording
+    if not tti.travel_times or p.force_tt_reset or tti.force_tt_reset then
+      tti.travel_times = {}
+      tti.station_order = {p.stn}
+      tti.recording_train = atc_id
+      tti.force_tt_reset = false
+      print(atc_id,"starting TT recording for",p.tt)
+    elseif tti.recording_train == atc_id then
+      tti.recording_train = nil
+    end
+    atc_set_text_outside(F.ttp[p.tt].outside_text)
+    atc_set_text_inside(p.stn.."\nArr: "
+        ..rwt.to_string(time_now, true).." Dep: "
+        ..rwt.to_string(next_dep_time, true))
+  end
+  if event.schedule then
+    -- departure. save actual departure time in tt
+    if S.ttt[atc_id] then -- failsafe: if entry is deleted externally somehow, train just departs and is not tracked by tt (makes resetting S.ttt possible)
+     S.ttt[atc_id].actual_dep = rwt.now()
+     local delay = rwt.diff(S.ttt[atc_id].desired_dep, S.ttt[atc_id].actual_dep)
+     atc_set_text_inside(F.ttp[p.tt].inside_line_desc .. "\nDelay: " .. rwt.to_string(delay, true))
+     S.ttt[atc_id].last_delay = delay
+    end
+    if p.reverse then
+      atc_send(RDEPCMD)
+    else
+      atc_send(DEPCMD)
+    end
+  end
+end
+--[[
+Generic stop on timetable. Any train that has a TT instance registered
+stops here, waits STOP_TIME and continues. Behavior can be altered by options:
+F.ttp_stop({
+ stn = "Personhood West", -- station name
+ doorside = "L",
+ only_lines = nil, --if given a table, only trains where only_lines[get_line()] is true are considered
+ end_of_tt = { TT_ID = true },
+   -- if present and key is true for a TT identifier, this is the last station on this timetable. Trains will stop recording timetable and be deregistered.
+ departure = { TT_ID = RWT relative to initial departure },
+   -- If present, override desired departure time. Defaults to travel time + STOP_TIME if not provided
+ no_disable_ars = nil,
+   -- if true, does not disable ARS on approach (used for example at INTERCAL)
+})
+]]
+function F.ttp_stop(p)
+  -- set my approach callback mode
+  __approach_callback_mode = 1
+  if not atc_id then
+    print(p.stn,"missing train!",event)
+    return
+  end
+  if not S.ttt[atc_id] then return end
+  if p.only_lines and not p.only_lines[get_line()] then return end
+  local trn = S.ttt[atc_id]
+  local tt = trn.timetable
+  if not F.ttp[tt] then
+    S.ttt[atc_id] = nil
+  end
+  local tti = S.ttp[tt]
+  if event.approach and not event.has_entered then
+    -- make the train stop
+    if not p.no_disable_ars then
+     atc_set_ars_disable(true)
+    end
+    atc_set_lzb_tsr(2)
+    atc_set_text_inside("Next stop: "..p.stn)
+  end
+
+--!-- disaster recovery --!--
+--  if event.approach and event.has_entered then
+--    print(atc_id,p.stn,"Disaster Recovery...")
+--    atc_send(DEPCMD)
+--  end
+
+
+  if event.train then
+    -- train arrived, planning departure
+    atc_send(STOPCMD..p.doorside)
+    local time_now = rwt.now()
+    -- update our location and determine desired and planned departure
+--L200
+    local next_dep_time = rwt.add(time_now, STOP_TIME)
+    trn.location = p.stn
+    trn.desired_dep = nil
+    trn.actual_dep = nil
+
+    -- calculate desired departure nouw
+    if p.departure and p.departure[tt] then
+      trn.desired_dep = rwt.add(trn.initial_dep or 0,
+          p.departure[tt])
+    elseif tti.travel_times[p.stn] then
+      trn.desired_dep = rwt.add(trn.initial_dep or 0,
+          tti.travel_times[p.stn] + STOP_TIME)
+      -- dyn travel time
+      if DYNAMIC_EN then
+        local ttpd = rwt.diff(next_dep_time, trn.desired_dep)
+        if ttpd > DYNAMIC_THR then
+          local new_trav = rwt.diff(trn.initial_dep, time_now) + DYNAMIC_THR
+          print(atc_id,tt,"arrived at",p.stn,ttpd,"s early, TT",tti.travel_times[p.stn],"->",new_trav)
+          tti.travel_times[p.stn] = new_trav
+          trn.desired_dep = rwt.add(trn.initial_dep or 0,
+              new_trav + STOP_TIME)
+        end
+      end
+    end
+
+    if trn.desired_dep then
+      -- if we had a source for desired departure, update planned daparture time
+      if rwt.to_secs(next_dep_time) < rwt.to_secs(trn.desired_dep) then
+        -- don't depart before the planned departure time
+        next_dep_time = trn.desired_dep
+      end
+      atc_set_text_inside(p.stn.."\nArr: "
+        ..rwt.to_string(time_now, true).." Plan: "
+        ..rwt.to_string(trn.desired_dep, true).." Dep: "
+        ..rwt.to_string(next_dep_time, true))
+
+      local delay = rwt.diff(trn.desired_dep, next_dep_time)
+      trn.last_delay = delay
+    else
+      atc_set_text_inside(p.stn.."\nAa "
+        ..rwt.to_string(time_now, true).." Dd ? Da"
+        ..rwt.to_string(next_dep_time, true))
+    end
+
+    if tti.recording_train == atc_id then
+      -- we are recording. save travel time
+      tti.travel_times[p.stn] = rwt.diff(trn.initial_dep or 0, time_now)
+      print(atc_id,"for",tt,"at",p.stn,"-> travel time",rwt.to_string(tti.travel_times[p.stn]))
+      tti.station_order[#tti.station_order+1] = p.stn
+      atc_set_text_inside(p.stn.."\nRec TT "
+        ..rwt.to_string(tti.travel_times[p.stn], true).." Da"
+        ..rwt.to_string(next_dep_time, true))
+    end
+
+    trn.planned_dep = next_dep_time
+    schedule(next_dep_time, "departure")
+  end
+  if event.schedule then
+    -- departure. save actual departure time in tt
+    trn.actual_dep = rwt.now()
+    local delay = rwt.diff(trn.desired_dep or trn.actual_dep, trn.actual_dep)
+    atc_set_text_inside(F.ttp[tt].inside_line_desc
+      .."\nDelay: "..rwt.to_string(delay, true))
+    S.ttt[atc_id].last_delay = delay
+    atc_send(DEPCMD)
+    if p.end_of_tt and p.end_of_tt[tt] then
+      -- end of timetable. Deregister train
+      if tti.recording_train == atc_id then
+        tti.recording_train = nil
+      end
+      S.ttt[atc_id] = nil
+    end
+  end
+end
+
+
+function F.ttp_info_times(tt, starttime)
+  --L307
+  local ttf = F.ttp[tt]
+  local tti = S.ttp[tt]
+  local p = {}
+  if tti.recording_train then
+    p[#p+1] = ("recording "..tti.recording_train)
+  end
+  p[#p+1] = ("Di "..rwt.to_string(starttime, false).." "..tti.station_order[1])
+  for i=2,#tti.station_order do
+    local ap = rwt.add(starttime, tti.travel_times[tti.station_order[i]])
+    p[#p+1] = ("Ap "..rwt.to_string(ap, true)..
+      " Dp "..rwt.to_string(rwt.add(ap, STOP_TIME), false)..
+      " "..tti.station_order[i])
+  end
+  return p
+end
+
+function F.ttp_info_trains(tt, starttime)
+  --L307
+  local ttf = F.ttp[tt]
+  local tti = S.ttp[tt]
+  local p = {}
+  for tid,trn in pairs(S.ttt) do
+    if trn.timetable==tt then
+      if trn.actual_dep then
+        p[#p+1] = ("Trn "..tid..
+          " after "..trn.location..
+          " Dd "..rwt.to_string(trn.desired_dep or 0, false)..
+          " Da "..rwt.to_string(trn.actual_dep, false)..
+          " Delay "..rwt.to_string(trn.last_delay or "59;59"))
+      else
+        p[#p+1] = ("Trn "..tid..
+          " at "..trn.location..
+          " Dd "..rwt.to_string(trn.desired_dep or 0, false)..
+          " Delay "..rwt.to_string(trn.last_delay or "59;59"))
+      end
+    end
+  end
+  return p
+end
+
+--[[F.ttp_station_display({
+ lines = {"CFE_S", "NX_S", "E1_S"},
+ departure = {},
+ station = "The Cube",
+ title = "The Cube (Track 2)",
+ interval = 30,
+ display1 = "d1",
+ display2 = "d2",
+ display3 = "d3",
+ show_trainid = false,
+}]]
+function F.ttp_station_display(p)
+  --L425
+  -- { dep, text }
+  local next_trains = {}
+  local function is_past_station(tstn, stnorder)
+    for _,s in ipairs(stnorder) do
+      if s==p.station then return true end
+      if s==tstn then return false end
+    end
+    return true
+  end
+
+  local function add_train(deptime, line, train, tid)
+    local tent = {dep = deptime, text =
+       rwt.to_string(deptime,true)
+       .." "..(p.show_trainid and tid.." " or "")
+       ..F.ttp[line].stn_display
+       .." +"..train.last_delay}
+    for i,ntrn in ipairs(next_trains) do
+      if rwt.diff(ntrn.dep, deptime)<0 then
+        table.insert(next_trains, i, tent)
+        return
+      end
+    end
+    table.insert(next_trains, tent)
+  end
+
+  for _,line in ipairs(p.lines) do
+    local fttp = F.ttp[line]
+    local sttp = S.ttp[line]
+    -- find all trains on this line
+    for id, train in pairs(S.ttt) do
+      if train.timetable == line then
+        if train.location == p.station and not train.actual_dep then
+          -- the train is currently standing at this station
+          add_train(train.planned_dep, line, train, id)
+        elseif not is_past_station(train.location, sttp.station_order) then
+          -- train is still approaching, calculate arrival time
+          local trav_dep = rwt.add(train.initial_dep, (sttp.travel_times[p.station] or 0) + STOP_TIME)
+          local act_dep = rwt.add(trav_dep, train.last_delay)
+          if p.departure and p.departure[line] then
+            local plan_dep = rwt.add(train.initial_dep, p.departure[line])
+            if rwt.to_secs(act_dep) < rwt.to_secs(plan_dep) then
+              act_dep = plan_dep
+            end
+          end
+          add_train(act_dep, line, train, id)
+        end
+      end
+    end
+  end
+
+  -- make output
+  local i
+  local text1 = p.title .. " * "..rwt.to_string(rwt.now(), true).." * "
+  for i=1,3 do
+    if next_trains[i] then
+      text1 = text1 .. "\n".. next_trains[i].text
+    end
+  end
+
+  digiline_send(p.display1, text1)
+  if p.display2 then
+    local text2 = ""
+    for i=4,7 do
+      if next_trains[i] then
+        text2 = text2 .. next_trains[i].text .. "\n"
+      end
+    end
+    digiline_send(p.display2, text2)
+  end
+
+  if p.display3 then
+    local text3 = ""
+    for i=8,11 do
+      if next_trains[i] then
+        text3 = text3 .. next_trains[i].text .. "\n"
+      end
+    end
+    digiline_send(p.display3, text3)
+  end
+  --if not p.notimer then
+  --  schedule_in(p.interval or 30,"foo")
+  --end
+end
diff --git a/far/nodes/(1753,8,1570).lua b/far/nodes/(1753,8,1570).lua
new file mode 100644
index 0000000..52fa2df
--- /dev/null
+++ b/far/nodes/(1753,8,1570).lua
@@ -0,0 +1,16 @@
+-- far_luaatctrack_spot_check_01.lua
+
+--[[
+F.ttp_begin({
+ stn = "Salt Factory", -- station name
+ tt = "FAR_E", -- timetable ID
+ depint = "05;00", --departure slot interval
+ depoff = "03;15", --departure slot offset
+ doorside = "L",
+ reverse = true,
+ only_lines = {['FAR'] = true},
+ force_tt_reset = false,
+})
+]]
+
+F.save_train(POS(1755,8,1570), "west")
diff --git a/far/nodes/(1755,8,1570).lua b/far/nodes/(1755,8,1570).lua
deleted file mode 100644
index 3b21dbf..0000000
--- a/far/nodes/(1755,8,1570).lua
+++ /dev/null
@@ -1,9 +0,0 @@
--- far_luaatctrack_spot_check_01.lua
--- POS(dd,dd,dd)
---[[
-POS(1755,8,1570)
-]]
-
-local show_print = false
-
-F.save_train(POS(1755,8,1570), "west")
-- 
cgit v1.2.3