Thu May 19 21:36:24 UTC 2022

init.lua

@@ -2,43 +2,67 @@
 -- Ich weiss jetzt noch nicht, wie viele verschiedene Versionen von dem Script spaeter herumfliegen werden.
 KsKitVer=0
 
--- Uebrige Konstanten
+Kennziffer=34
-Vmax=400
 
--- Tabelle, in der alle Lambda-Funktionen gespeichert werden
+local Callbacks = {}
--- Die Eintragung erfolgt durch die MainFunktion() vom Zielort aus.
-MainFunktionTabelle={}
 
--- Neues Main-Lambda registrieren
+function On(Name, Funktion)
-function MainFunktion(Funktion)
+  -- Erlaube es, Signal und Weichen via Nummer zu referenzieren
-  table.insert(MainFunktionTabelle, Funktion)
+  if type(Name) == "number" then
-end
+    if EEPGetSwitch(Name) > 0 then
-
+      Name = "EEPOnSwitch_"..tostring(Name)
--- Alle Main-Lambda's ausfuehren
+    elseif EEPGetSignal(Name) > 0 then
--- Dies ersetzt die Standard-EEP-Main Funktion.
+      Name = "EEPOnSignal_"..tostring(Name)
-function EEPMain()
-  for cnt = 1, #MainFunktionTabelle do
-   MainFunktionTabelle[cnt]()
     end
+  end
+  if type(Name) == "table" then
+    for _, Newname in pairs(Name) do
+      On(Newname, Funktion)
+    end
+    return
+  end
+  if type(Name) ~= "string" or string.match(Name, "EEP.+") == nil then
+    print("Verweigere Callback von "..type(Name).." "..tostring(Name))
+    return
+  end
+  if not Callbacks[Name] then
+    Callbacks[Name] = {}
+    if _G[Name] ~= nil then
+      print("Warnung: "..Name.."() von KsKit adoptiert")
+      table.insert(Callbacks[Name], _G[Name])
+    end
+    _G[Name] = function(...)
+      for cnt = 1, #Callbacks[Name] do
+        Callbacks[Name][cnt](...)
+      end
+      -- Nur EEPMain braucht dies, aber dringends
       return 1
+    end
+    -- Bei Weichen und Signalen muss EEP vorher informiert werden
+    -- Item ist normal "Switch" oder "Signal"
+    local Item, Number = string.match(Name, 'EEPOn(.+)_(%d+)')
+    if Number ~= nil then
+      _G["EEPRegister"..Item](Number)
+    end
+  end
+  table.insert(Callbacks[Name], Funktion)
 end
 
--- Neues Signal-Lambda registrieren
+-- EEPMain-Callback registrieren
-SignalFunktionen = {}
+function Main(Funktion)
-function SignalFunktion(Signal, Funktion)
+  On("EEPMain", Funktion)
-  if not SignalFunktionen[Signal] then
+end
+
+-- Signal-Callback registrieren
+function OnSignal(Signal, Funktion)
   EEPRegisterSignal(Signal)
-    -- Callback bei EEP registrieren
+  On("EEPOnSignal_"..tostring(Signal), Funktion)
-    _G["EEPOnSignal_"..tostring(Signal)]=function(Stellung)
+end
-      -- Alle registrierten Lambdas ausfuehren
+
-      for cnt = 1, #SignalFunktionen[Signal] do
+-- Weichen-Callbacks registrieren
-       SignalFunktionen[Signal][cnt](Stellung)
+function OnSwitch(Switch, Funktion)
-      end
+  EEPRegisterSwitch(Switch)
-    end
+  On("EEPOnSwitch_"..tostring(Switch), Funktion)
-    SignalFunktionen[Signal]={}
-  end
-  -- In unsere eigene Tabelle eintragen
-  table.insert(SignalFunktionen[Signal], Funktion)
 end
 
 -- Lua-Serializer und Deserializer laden
@@ -60,100 +84,130 @@ function speicherTabelle(Slot, Tabelle)
   EEPSaveData(Slot, serpent.line(Tabelle, {comment = false}))
 end
 
-SignalLesenFunktionen={}
+-- Referenz-Datenbank mit Signalen, Fahrstrassen & Weichen
+-- Geordnet nach Signal/Weichen-ID
+KsSignale = {}
 
--- Definiere ein Signal
+-- KsSignale von GK3 sind sehr systematisch benannt, die moeglichen Stellungen lassen sich aus dem Namen herleiten
--- Signal: ID-Nummer
+function GK3KsBegriffe(Modell)
--- Haltstellung: Nummer der Haltstellung, meistens 1
+  local Teile = {}
--- SchaltFunk: Callback, wird wiederholt aufgerufen, um Fahrt-Stellung des Signals zu erwirken
+  for str in string.gmatch(Modell, "([^_ ]+)") do
--- AbmeldeFunk: Wird nach Durchfahrt am Signal aufgerufen
+    Teile[str]=true
-function Basissignal(Signal, Haltstellung, SchaltFunk, AbmeldeFunk)
-  if EEPGetSignal(Signal)==0 then
-    print("Anlagen-Fehler: ID ",Signal," ist kein Signal")
-    return
   end
-  -- Funktion, damit anderer Programmcode das Signal lesen kann
+  local Stellungen = {}
-  SignalLesenFunktionen[Signal]=function()
+
-    local Stellung = EEPGetSignal(Signal)
+  -- Halt am Hauptsignal
-    if Stellung == 0 or Stellung == Haltstellung then
+  if Teile["A"] or Teile["B"] then
-      return false, 0
+    table.insert(Stellungen, {"Hp0"})
   end
-    return true, Vmax
+
+  -- Halt erwarten
+  -- ... am Wiederholer 
+  if Teile["VSigWdh"] then
+    table.insert(Stellungen, {"Ks2","Kl"})
   end
-  -- Funktion fuer Kontaktpunkte: Zug an Signal anmelden
+  -- ... An MAS oder Vorsignalen
-  _G["Anmeldung_"..tostring(Signal)] = function(Zug)
+  if Teile["MAS"] or Teile["VSig"] then
-    local Anmeldung
+    if Teile["verkuerzt"] then
-    Anmeldung = ladeTabelle(Signal)
+      table.insert(Stellungen, {"Ks2","Kl"})
-    if Anmeldung.train and Anmeldung.train ~= Zug then return end
-    Anmeldung.train = Zug
-    speicherTabelle(Signal, Anmeldung)
     end
-  -- Auftragsstatus pollen
+    table.insert(Stellungen, {"Ks2"})
-  MainFunktion(function()
+    if Teile["Kl"] then
-    local Anmeldung = ladeTabelle(Signal)
+      table.insert(Stellungen, {"Ks2","Kl"})
-    -- Wenn Zug vor Signal steht, Anmeldung ggf. nachholen
-    if EEPGetSignalTrainsCount(Signal) > 0 then
-      if Anmeldung.train == nil then
-        Anmeldung.train = EEPGetSignalTrainName(Signal, 1)
-        speicherTabelle(Signal, Anmeldung)
-      end
-      -- Ankunftszeit merken, sobald Zug am Signal angekommen ist
-      -- Wird im if von EEPGetSignalTrainsCount gemacht,
-      --   damit nur Halte an diesem Signal zaehlen
-      if Anmeldung.arrival == nil then
-        ok, speed = EEPGetTrainSpeed(Anmeldung.train)
-        if math.abs(speed) < 5 then
-          Anmeldung.arrival = EEPTime
-          speicherTabelle(Signal, Anmeldung)
     end
   end
+
+  -- Fahrt/Fahrt erwarten
+  table.insert(Stellungen, {"Ks1"})
+
+  -- Langsamfahrt erwarten
+  -- ... am Wiederholer
+  if Teile["VSigWdh"] then
+    table.insert(Stellungen, {"Ks1bl","Kl"})
   end
-    -- Nichts tun wenn kein Zug da
+  -- ... am MAS oder Vorsignalen
-    if Anmeldung.train == nil then return end
+  if Teile["MAS"] or Teile["VSig"] or Teile["VSigWdh"] then
-    -- SchaltFunk
+    if Teile["verkuerzt"] then
-    if SchaltFunk and EEPGetSignal(Signal) == Haltstellung then
+      table.insert(Stellungen, {"Ks1bl","Kl"})
-      r=SchaltFunk(Anmeldung.train)
+    end
-      if r and r > 0 and r ~= Haltstellung then
+    table.insert(Stellungen, {"Ks1bl"})
-        EEPSetSignal(Signal, r, 1)
+    if Teile["Kl"] then
+      table.insert(Stellungen, {"Ks1bl","Kl"})
     end
   end
-  end)
+
-  -- Reaktion auf Signal-Umstellungen
+  -- Rangierfahrt an Ausfahrsignalen
-  SignalFunktion(Signal, function(Stellung)
+  if Teile["A"] then
-    if Stellung == Haltstellung then
+    table.insert(Stellungen, {"Sh1"})
-      -- Wenn Signal auf Halt gestellt wurde, mache eine Abmeldung
-      if AbmeldeFunk then
-        local Anmeldung = ladeTabelle(Signal)
-        AbmeldeFunk(Anmeldung.train)
   end
-      speicherTabelle(Signal, {})
+
+  -- Ersatzfahrt an Ausfahrsignalen und Blocksignalen ohne Vorsichtssignal
+  if Teile["A"] or (Teile["B"] and not Teile["V"]) then
+    table.insert(Stellungen, {"Zs1"})
   end
-  end)
+
+  -- Vorsichtssignal an Hauptsignalen
+  if Teile["V"] then
+    table.insert(Stellungen, {"Zs7"})
+  end
+
+  -- Kennlicht
+  if Teile["Kl"] or Teile["VSigWdh"] or Teile["verkuerzt"] then
+    table.insert(Stellungen, {"Kl"})
+  end
+
+  -- Dunkel geschaltet
+  table.insert(Stellungen, {})
+  return Stellungen
 end
 
--- Funktion zum Erklaeren, was ein Signal gerade so tut
+local GK3KsBauarten={
--- Nimmt die Nummer des Signals als Argument
+  "Ks_Sig_A",
--- Gibt einen Menschenlesbaren Text zurueck
+  "Ks_Sig_A_MAS",
-function SignalBeschreibung(Signal)
+  "Ks_Sig_A_MAS_Kl",
-  local Anmeldung = ladeTabelle(Signal)
+  "Ks_Sig_A_V",
-  local Fahrt, V = SignalLesenFunktionen[Signal]()
+  "Ks_Sig_A_V_MAS",
-  Text = "Signal " .. tonumber(Signal) .. ": "
+  "Ks_Sig_A_V_MAS_Kl",
-  if Fahrt then
+  "Ks_Sig_B",
-    if V < Vmax then
+  "Ks_Sig_B_MAS",
-      Text = Text .. "Fahrt mit " .. tonumber(V) .. " Km/h\n"
+  "Ks_Sig_B_V",
-    else
+  "Ks_Sig_B_V_MAS",
-      Text = Text .. "Fahrt\n"
+  "Ks_Sig_B_V_MAS_Kl",
+  "Ks_Sig_VSig",
+  "Ks_Sig_VSigWdh",
+  "Ks_Sig_VSig_verkuerzt"
+}
+
+for cnt=1, #GK3KsBauarten do
+  _G[GK3KsBauarten[cnt]]=function(Signal, Meta)
+    -- Falls kein name gegeben, einen generieren
+    if Meta.Name == nil then
+      Meta.Name = string.format("%d", Signal)
+    end
+    Meta.Kennziffer = Kennziffer
+    Meta.Begriffe = GK3KsBegriffe(GK3KsBauarten[cnt])
+    for _, Var in ipairs({"Schild","Mastschild","Immobilie", "PZB"}) do
+      if type(Meta[Var]) == "number" then
+        Meta[Var]=tostring("#"..Meta[Var])
+      end
+      if Meta[Var] then
+        local ok,x,y,z = EEPStructureGetPosition(Meta[Var])
+        if ok then
+          if not Meta.Ort then
+            Meta.Ort = {x,y,z}
           end
         else
-    Text = Text .. "Halt\n"
+          print("Warnung: Signal ",Signal," ",Var," ",Meta[Var]," nicht gefunden")
         end
-  if Anmeldung.train then
-    Text = Text .. "Zug angemeldet: " .. Anmeldung.train .. "\n"
       end
-  if Anmeldung.arrival then
-    local Dauer = EEPTime - Anmeldung.arrival
-    if Dauer < 0 then Dauer = Dauer + 24*60*60 end
-    Text = Text .. "Ankunft vor " .. Dauer .. " Sekunden\n"
     end
-  return Text
+    if not Meta.Ort then
+      print("Warnung: Signal ",Signal," hat keine Immobilie, um die eigene Position zu ermitteln")
+    end
+    KsSignale[Signal] = Meta
+    if Meta.Schild then
+      EEPStructureSetTextureText(Meta.Schild, 1, Meta.Kennziffer)
+      EEPStructureSetTextureText(Meta.Schild, 2, Meta.Name)      
+    end
+  end
 end