Schoenenberger_Systeme_GmbH/dxfmakros
7
0
Fork 0
Code Issues 1 Pull Requests Actions Packages Projects Releases Wiki Activity

feat: Modus 3 mit optionalem AS/ES, ES-Frage vor dem Bau; Helfer rollenbasiert benannt

Browse Source 
WARUM MODUS 3 BLEIBT
Modus 2 und 3 arbeiten beide auf einem gezeichneten Pfad (LINE/ARC), aber sie
loesen verschiedene Aufgaben:
  Modus 2 = Randwertproblem - Start UND Ziel (je X/Y/Z) sind bekannt, die
            Zwischenhoehen werden gerechnet, die Zielhoehe wird exakt
            getroffen.
  Modus 3 = Anfangswertproblem - die Kette wird mit vorgegebenen Winkeln
            vorwaerts durchgebaut, die Endhoehe ist das ERGEBNIS.
Modus 3 kann damit etwas, was Modus 2 grundsaetzlich nicht kann: ohne
vorgegebene Zielhoehe arbeiten ("folge dieser Linie mit 3 Grad und lass uns
sehen, wo wir landen") - und er hat keinen Solver, der scheitern kann.
Dazu kommt ein harter Bestandsgrund: Modus 3 schreibt ein eigenes Journal
(Marker "linienzug3") und ist per Doppelklick editierbar. Faellt der Code
weg, verlieren alle bereits damit gebauten Ketten ihren Editier-Pfad.
Der Stempel "Legacy / wird umgebaut" war ueberholt und ist raus.

MODUS 3 - DREI AENDERUNGEN (Nutzer-Vorgabe 2026-10-22)
1. "AS bauen?" und 2. "ES bauen?" sind jetzt abfragbar (vorher wurden beide
   immer gebaut), zusammen mit Winkel und Seite in je EINEM Dialog - dasselbe
   Muster, das Modus 2 schon nutzt (vflw-gruppe-as-impl), kein neuer Code.
   Ohne AS beginnt die Kette direkt am Startpunkt (flacher Rahmen statt
   Block); die Fussabdruck-Trimmung der ersten Geraden rechnet dann von
   selbst 0, weil Rahmen und Startpunkt zusammenfallen.
3. Die ES-Frage steht jetzt VOR dem Bau. Das behebt einen echten Fehler: die
   letzte Gerade wird um "Separator + ein-dx" gekuerzt, ein-dx wurde aber
   gelesen, BEVOR es gesetzt war - beim ersten Lauf griff der Schaetzwert
   *vfk-as-es-fallback-dx*, bei jedem weiteren stand dort der Wert der
   VORHERIGEN Kette (falscher Winkel, falsche Seite). Jetzt traegt die
   Trimmung den echten Fussabdruck der gewaehlten ES-Variante; ohne ES
   entfaellt sie ganz.

ABWAERTSKOMPATIBILITAET
Das Verschieben der ES-Frage aendert die Journal-Reihenfolge. Bestehende
"linienzug3"-Ketten bleiben per Doppelklick nachbaubar: alt-journal erkennt
sie am WERT des ersten Antwort-Eintrags ("30"/"90" = alt, "1"/"2" = neu, die
Mengen sind disjunkt) und spielt sie in der alten Reihenfolge ab. Dafuer der
neue Helfer vfl-replay-peek-wert neben vfl-replay-peek-art.

DIALOG vflw_as
Die Seitenauswahl wurde bei 30 Grad ausgegraut und NICHT in die Pending-Queue
gelegt - eine reine Modus-1-Regel (dort ersetzte die Zufuehrungsachse die
Seitenfrage). Modus 1 hat seit 2026-10-21 seinen eigenen Dialog; uebrig
blieben ES-Element sowie Modus 2/3, wo die Seite IMMER gebraucht wird - dort
ging bei 30 Grad ein zweites Fenster nur fuer die Seite auf. Entfernt.

NAMENSSCHEMA (faellt in denselben Commit, weil dieselbe Datei)
Die Helfer-Praefixe vfl2-/vfl3- stammten aus einer Planungsphase vor der
endgueltigen Menue-Zuordnung und waren dazu VERTAUSCHT: alle vfl3-* gehoeren
zu Modus 2, die vfl2-* zu Modus 3 - und drei davon zu BEIDEN. Eine
Modus-Nummer war fuer diese drei also gar nicht richtig vergebbar. Sie heissen
jetzt nach ihrer Rolle: vfl-zsolve-* (rechnet die Hoehen durch, nur Modus 2)
und vfl-pfad-* (arbeitet am gezeichneten Pfad, Modus 2 UND 3). 18 Funktionen,
jede Aufrufstelle maschinell gegen die Definitionen geprueft. Die falsche
Block-Ueberschrift "MODUS 3: Pfad + Ziel-Hoehe" (gemeint war Modus 2) ist
korrigiert, beide Gruppen haben jetzt einen erklaerenden Kopf.
vfl-zsolve-bruecke (frueher vfl3-solve-bruecke) wird von niemandem aufgerufen
- bewusst stehen gelassen und markiert, Loeschen gehoert in ein
Tote-Code-Review.

MENUE
Die Modi heissen jetzt nach ihrem Unterschied statt nach der Bedienung:
"aus 3D Linie mit Zielhoehe" / "aus 3D Linie ohne Zielhoehe" (vorher
"3D Objekte stueckweise (in Arbeit)").

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
This commit is contained in:
Yuelin Wang
2026-10-22 12:01:16 +02:00
parent 1cc163dc11
commit e1e5fbf0c1
10 changed files with 254 additions and 137 deletions
Download Patch File Download Diff File Expand all files Collapse all files
CLAUDE.md
+1 -1
View File
File diff suppressed because one or more lines are too long
Lisp/vf_konstanten.lsp
+4 -4
View File
@@ -101,8 +101,8 @@
(if (null *vfk-etage-hz-winkel*) (setq *vfk-etage-hz-winkel* 30.0)) (if (null *vfk-etage-hz-winkel*) (setq *vfk-etage-hz-winkel* 30.0))
;; Eckwinkel-Toleranz bei der automatischen Pfad-Klassifizierung (Modus 3, ;; Eckwinkel-Toleranz bei der automatischen Pfad-Klassifizierung (Modus 3,
;; vf-linienzug-modus3 -> vfl2-pruefe-eckwinkel). Aktiv referenziert in ;; vf-linienzug-modus3 -> vfl-pfad-eckwinkel-pruefen). Aktiv referenziert in
;; vf_linienzug.lsp (beide Aufrufstellen von vfl2-pruefe-eckwinkel). ;; vf_linienzug.lsp (beide Aufrufstellen von vfl-pfad-eckwinkel-pruefen).
(if (null *vfk-eckwinkel-toleranz*) (setq *vfk-eckwinkel-toleranz* 5.0)) (if (null *vfk-eckwinkel-toleranz*) (setq *vfk-eckwinkel-toleranz* 5.0))
;; Schwellwert (Grad), ab dem ein Frame noch als "flach" (~0 Grad) gilt. ;; Schwellwert (Grad), ab dem ein Frame noch als "flach" (~0 Grad) gilt.
@@ -123,7 +123,7 @@
;; (vf_etage.lsp Z.41) ;; (vf_etage.lsp Z.41)
;; - Linienzug-Kettenende/Body-Abschluss (nur Motor+1 Separator, KEIN ;; - Linienzug-Kettenende/Body-Abschluss (nur Motor+1 Separator, KEIN
;; Umlenk-Anteil): 800 als rohes Literal an >10 Stellen in ;; Umlenk-Anteil): 800 als rohes Literal an >10 Stellen in
;; vf_linienzug.lsp (vfl-body-zerlegung, vfl3-waehle-winkel, ...) ;; vf_linienzug.lsp (vfl-body-zerlegung, vfl-zsolve-winkel-waehlen, ...)
;; Diese vier NICHT vereinheitlichen ohne sorgfaeltige Pruefung - sie ;; Diese vier NICHT vereinheitlichen ohne sorgfaeltige Pruefung - sie
;; entstehen aus unterschiedlicher Bauteil-Zusammensetzung (siehe jeweiliger ;; entstehen aus unterschiedlicher Bauteil-Zusammensetzung (siehe jeweiliger
;; Kommentar im Modul), keine Kopiergleichheit. ;; Kommentar im Modul), keine Kopiergleichheit.
@@ -166,7 +166,7 @@
;; Mindestlaenge (mm) fuer die 3-Grad-GF-Anschlussstrecke (GF1 am Einlauf ;; Mindestlaenge (mm) fuer die 3-Grad-GF-Anschlussstrecke (GF1 am Einlauf
;; einer VF-Einheit). Bereits als *vfl-gf-min-laenge* in vf_linienzug.lsp ;; einer VF-Einheit). Bereits als *vfl-gf-min-laenge* in vf_linienzug.lsp
;; benannt (Wert 400.0) - hier nur gespiegelt. Das fruehere rohe 400.0- ;; benannt (Wert 400.0) - hier nur gespiegelt. Das fruehere rohe 400.0-
;; Duplikat (br-gf1 in vfl3-*) referenziert jetzt *vfl-gf-min-laenge*. ;; Duplikat (br-gf1 in vfl-zsolve-*) referenziert jetzt *vfl-gf-min-laenge*.
(if (null *vfk-gf-anschluss-mindestlaenge*) (setq *vfk-gf-anschluss-mindestlaenge* 400.0)) (if (null *vfk-gf-anschluss-mindestlaenge*) (setq *vfk-gf-anschluss-mindestlaenge* 400.0))
;; ============================================================ ;; ============================================================
Lisp/vf_linienzug.lsp
+208 -109
View File
@@ -382,6 +382,18 @@
(while (and q (= (car (car q)) "STEP")) (setq q (cdr q))) (while (and q (= (car (car q)) "STEP")) (setq q (cdr q)))
(if q (car (car q)) nil)) (if q (car (car q)) nil))
;; WERT des naechsten Replay-Eintrags, ohne ihn zu verbrauchen (nil bei leerer
;; Queue). Gegenstueck zu vfl-replay-peek-art fuer den Fall, dass die ART
;; allein nicht reicht: wird an einer Stelle eine neue Frage GLEICHEN Typs
;; eingefuegt, unterscheidet nur noch der Wert alt von neu. Genutzt in
;; vf-linienzug-modus3, wo seit 2026-10-22 ein "AS bauen?" (STR "1"/"2") VOR
;; dem AS-Winkel (STR "30"/"90") steht - die beiden Wertemengen sind disjunkt,
;; ein Blick auf den Wert erkennt das Alt-Journal also eindeutig.
(defun vfl-replay-peek-wert ( / q)
(setq q *vfl-replay-queue*)
(while (and q (= (car (car q)) "STEP")) (setq q (cdr q)))
(if q (cdr (car q)) nil))
;; ============================================================ ;; ============================================================
;; TEIL 0b-1b: GLIED-SCHEMA (single source of truth) ;; TEIL 0b-1b: GLIED-SCHEMA (single source of truth)
;; ============================================================ ;; ============================================================
@@ -910,33 +922,24 @@
" -> Achse " " -> Achse "
(rtos (vfl-planar-hz achse-basis gpunkt) 2 1) (rtos (vfl-planar-hz achse-basis gpunkt) 2 1)
" Grad"))))) " Grad")))))
;; Seitenauswahl ist OHNE Achsen-Dialog nur beim 90-Grad-Element ;; Die Seite ist in JEDEM verbleibenden Anwendungsfall noetig und daher
;; wirksam: dort folgt die Seite beim 30-Grad-Element aus der ;; auch beim 30-Grad-Element waehlbar. Bis 2026-10-22 wurde sie dort
;; Zufuehrungsachse (Nutzer-Vorgabe 2026-10-14). Sie wird darum ;; ausgegraut und NICHT in die Pending-Queue gelegt - das war eine
;; ausgegraut - und unten auch NICHT in die Pending-Queue gelegt, sonst ;; reine Modus-1-Regel (dort ersetzte die Zufuehrungsachse die
;; zoege die Punktfrage sie als vermeintlichen Punkt heraus und ;; Seitenfrage). Modus 1 hat seit 2026-10-21 seinen eigenen Dialog
;; erschiene gar nicht. MIT Achsen-Dialog wird die Seite dagegen immer ;; (vflw_as_achse), uebrig bleiben ES-Element sowie Modus 2/3 - und
;; gebraucht (sie ist die AS-Variante, nicht mehr aus der Achse ;; dort fuehrte die Ausgrauung dazu, dass bei 30 Grad ein ZWEITES
;; ableitbar) und bleibt daher auch bei 30 Grad waehlbar. ;; Fenster nur fuer die Seite aufging (die nachfolgende Frage fand
;; keinen Wert in der Queue).
(action_tile "setzen" (action_tile "setzen"
(if mit-achse (strcat
"(mode_tile \"winkel_90\" (if (= (get_tile \"setzen\") \"1\") 0 1)) "(mode_tile \"winkel_90\" (if (= (get_tile \"setzen\") \"1\") 0 1))
(mode_tile \"winkel_30\" (if (= (get_tile \"setzen\") \"1\") 0 1)) (mode_tile \"winkel_30\" (if (= (get_tile \"setzen\") \"1\") 0 1))
(mode_tile \"seite_links\" (if (= (get_tile \"setzen\") \"1\") 0 1)) (mode_tile \"seite_links\" (if (= (get_tile \"setzen\") \"1\") 0 1))
(mode_tile \"seite_rechts\" (if (= (get_tile \"setzen\") \"1\") 0 1)) (mode_tile \"seite_rechts\" (if (= (get_tile \"setzen\") \"1\") 0 1))"
(mode_tile \"pick\" (if (= (get_tile \"setzen\") \"1\") 0 1))" (if mit-achse
"(mode_tile \"winkel_90\" (if (= (get_tile \"setzen\") \"1\") 0 1)) "(mode_tile \"pick\" (if (= (get_tile \"setzen\") \"1\") 0 1))"
(mode_tile \"winkel_30\" (if (= (get_tile \"setzen\") \"1\") 0 1)) "")))
(mode_tile \"seite_links\" (if (and (= (get_tile \"setzen\") \"1\") (/= (get_tile \"winkel_30\") \"1\")) 0 1))
(mode_tile \"seite_rechts\" (if (and (= (get_tile \"setzen\") \"1\") (/= (get_tile \"winkel_30\") \"1\")) 0 1))"))
(if (not mit-achse)
(progn
(action_tile "winkel_30"
"(mode_tile \"seite_links\" 1)
(mode_tile \"seite_rechts\" 1)")
(action_tile "winkel_90"
"(mode_tile \"seite_links\" (if (= (get_tile \"setzen\") \"1\") 0 1))
(mode_tile \"seite_rechts\" (if (= (get_tile \"setzen\") \"1\") 0 1))")))
(if mit-achse (if mit-achse
(action_tile "pick" (action_tile "pick"
"(setq gsetzen (get_tile \"setzen\")) "(setq gsetzen (get_tile \"setzen\"))
@@ -974,13 +977,11 @@
;; Winkel-Slot wird von vfl-in-value (AS-Winkel, ueber ;; Winkel-Slot wird von vfl-in-value (AS-Winkel, ueber
;; vf-frage-element-winkel) konsumiert - der erwartet direkt ;; vf-frage-element-winkel) konsumiert - der erwartet direkt
;; "30"/"90", NICHT den Auswahl-Index wie beim Seite-Slot. ;; "30"/"90", NICHT den Auswahl-Index wie beim Seite-Slot.
;; Die Seite geht IMMER mit (siehe Kommentar oben), nur der
;; Achsen-Punkt haengt am Dialogtyp.
(if mit-achse (if mit-achse
(vflw-pending-push-all (list "1" gwinkel gseite gpunkt)) (vflw-pending-push-all (list "1" gwinkel gseite gpunkt))
;; Ohne Achsen-Dialog beim 30-Grad-Element KEINE Seite (vflw-pending-push-all (list "1" gwinkel gseite)))
;; mitgeben (siehe Kommentar oben).
(if (= gwinkel "30")
(vflw-pending-push-all (list "1" gwinkel))
(vflw-pending-push-all (list "1" gwinkel gseite))))
(vflw-pending-push-all (list "2")))) (vflw-pending-push-all (list "2"))))
((= ergebnis (if mit-achse 3 2)) ((= ergebnis (if mit-achse 3 2))
(setq fertig t) (setq *vfl-wizard-abbruch-grund* "zurueck")) (setq fertig t) (setq *vfl-wizard-abbruch-grund* "zurueck"))
@@ -9800,9 +9801,22 @@
;; - GF-Bogen hat feste Eigen-Neigung -> bei unterschiedlichen Nachbar- ;; - GF-Bogen hat feste Eigen-Neigung -> bei unterschiedlichen Nachbar-
;; Neigungen entsteht ein (akzeptierter) Knick. ;; Neigungen entsteht ein (akzeptierter) Knick.
;; ============================================================
;; PFAD-HELFER (vfl-pfad-*) - geteilt von MODUS 2 UND MODUS 3
;; ============================================================
;; Alles, was auf dem GEZEICHNETEN Pfad arbeitet: Eckwinkel pruefen,
;; AS-Element einfuegen, VF-Einheit oeffnen/schliessen. Bewusst OHNE
;; Modus-Nummer im Namen - bis 2026-10-22 hiessen sie vfl2-*, was zu Modus 2
;; passte, obwohl die Haelfte davon zu Modus 3 gehoert und drei von ihnen von
;; BEIDEN Modi benutzt werden (vfl-pfad-eckwinkel-pruefen,
;; vfl-pfad-as-gf-einfuegen, vfl-pfad-as-vf-einfuegen). Eine Nummer waere hier
;; also gar nicht richtig vergebbar; der Name nennt jetzt die Rolle.
;; Gegenstueck: vfl-zsolve-* (Hoehen-Rechenkern von Modus 2, weiter unten).
;; ============================================================
;; Alle Eck-Winkel des Pfades gegen 30/60/90 Grad pruefen (Toleranz tol). ;; Alle Eck-Winkel des Pfades gegen 30/60/90 Grad pruefen (Toleranz tol).
;; Rueckgabe: nil (alle ok) oder der erste abweichende Winkel (Grad). ;; Rueckgabe: nil (alle ok) oder der erste abweichende Winkel (Grad).
(defun vfl2-pruefe-eckwinkel (kette tol / item obj sa ea sweep bad) (defun vfl-pfad-eckwinkel-pruefen (kette tol / item obj sa ea sweep bad)
(setq bad nil) (setq bad nil)
(foreach item kette (foreach item kette
(setq obj (car item)) (setq obj (car item))
@@ -9829,12 +9843,12 @@
;; Ergebnis: KS_EIN.X = Startpunkt.X, KS_EIN quer um das AS-Y-Mass versetzt, ;; Ergebnis: KS_EIN.X = Startpunkt.X, KS_EIN quer um das AS-Y-Mass versetzt,
;; KS_AUS liegt exakt auf dem Pfad -> die ganze Kette folgt der Mittellinie. ;; KS_AUS liegt exakt auf dem Pfad -> die ganze Kette folgt der Mittellinie.
;; Rueckgabe: (korrigierter) Frame am KS_AUS. ;; Rueckgabe: (korrigierter) Frame am KS_AUS.
;; winkel-Parameter bleibt aus Call-Kompatibilitaet bestehen (vfl2-insert-as-vf ;; winkel-Parameter bleibt aus Call-Kompatibilitaet bestehen (vfl-pfad-as-vf-einfuegen
;; ruft mit 0.0), wird aber NICHT mehr fuer eine Kippung verwendet: das AS- ;; ruft mit 0.0), wird aber NICHT mehr fuer eine Kippung verwendet: das AS-
;; Element hat keine eigene Neigung (per Einzel-Insert-Test in BricsCAD ;; Element hat keine eigene Neigung (per Einzel-Insert-Test in BricsCAD
;; bestaetigt, siehe vfl-insert-as-element in Modus 1) - unabhaengig vom ;; bestaetigt, siehe vfl-insert-as-element in Modus 1) - unabhaengig vom
;; folgenden Segmenttyp (GF/VF) wird es IMMER flach eingefuegt. ;; folgenden Segmenttyp (GF/VF) wird es IMMER flach eingefuegt.
(defun vfl2-insert-as-gf (startpunkt hz winkel as-seite / (defun vfl-pfad-as-gf-einfuegen (startpunkt hz winkel as-seite /
ein-hz-as rad-h xu-ein frame blk ks-aus ein-hz-as rad-h xu-ein frame blk ks-aus
rad-hz perp-x perp-y d-perp sx sy as-turn rad-hz perp-x perp-y d-perp sx sy as-turn
rad-ein de-x de-y de-dot-np t-shift) rad-ein de-x de-y de-dot-np t-shift)
@@ -9877,12 +9891,12 @@
;; (0 Grad Neigung). Das AS wird mit KS_EIN auf den Startpunkt gesetzt und dann ;; (0 Grad Neigung). Das AS wird mit KS_EIN auf den Startpunkt gesetzt und dann
;; senkrecht zu hz auf den Pfad geschoben (reine KS-Kettung, KS_AUS auf Pfad). ;; senkrecht zu hz auf den Pfad geschoben (reine KS-Kettung, KS_AUS auf Pfad).
;; Damit liegt auch eine mit VF beginnende Kette auf dem gezeichneten Pfad. ;; Damit liegt auch eine mit VF beginnende Kette auf dem gezeichneten Pfad.
(defun vfl2-insert-as-vf (startpunkt hz as-seite) (defun vfl-pfad-as-vf-einfuegen (startpunkt hz as-seite)
(vfl2-insert-as-gf startpunkt hz 0.0 as-seite)) (vfl-pfad-as-gf-einfuegen startpunkt hz 0.0 as-seite))
;; VF-Einheit OEFFNEN (Modus 2): GF1 (Basis-Staustrecke) + Separator + ;; VF-Einheit OEFFNEN (Modus 2): GF1 (Basis-Staustrecke) + Separator +
;; Umlenkstation. Rueckgabe: Frame nach der Umlenkstation (Beginn reiner VF). ;; Umlenkstation. Rueckgabe: Frame nach der Umlenkstation (Beginn reiner VF).
(defun vfl2-vf-open (frame hz / f) (defun vfl-pfad-vf-oeffnen (frame hz / f)
(setq f (vfl-frame-3grad (vfs-vf-entry (car frame) *vfl-gf-min-laenge* hz nil) hz)) (setq f (vfl-frame-3grad (vfs-vf-entry (car frame) *vfl-gf-min-laenge* hz nil) hz))
(if (> *vfl-gf-min-laenge* 0.1) (if (> *vfl-gf-min-laenge* 0.1)
(vfl-acc-gf-seg *vfl-gf-min-laenge* (ssg-cfg-or "vario" "gefaelle_winkel" 3))) (vfl-acc-gf-seg *vfl-gf-min-laenge* (ssg-cfg-or "vario" "gefaelle_winkel" 3)))
@@ -9891,7 +9905,7 @@
;; VF-Einheit SCHLIESSEN (Modus 2): Motorstation + GF2 (Basis), KEIN Separator ;; VF-Einheit SCHLIESSEN (Modus 2): Motorstation + GF2 (Basis), KEIN Separator
;; (der sitzt erst am Kettenende bzw. optional zwischen Foerderern). Rueckgabe: ;; (der sitzt erst am Kettenende bzw. optional zwischen Foerderern). Rueckgabe:
;; Frame nach GF2. ;; Frame nach GF2.
(defun vfl2-vf-close (frame hz / f) (defun vfl-pfad-vf-schliessen (frame hz / f)
(setq *vfl-acc-motorseite* (append *vfl-acc-motorseite* (list "rechts"))) (setq *vfl-acc-motorseite* (append *vfl-acc-motorseite* (list "rechts")))
(setq f (vfl-frame-3grad (vfs-vf-exit (car frame) *vfl-gf-min-laenge* hz nil) hz)) (setq f (vfl-frame-3grad (vfs-vf-exit (car frame) *vfl-gf-min-laenge* hz nil) hz))
(if (> *vfl-gf-min-laenge* 0.1) (if (> *vfl-gf-min-laenge* 0.1)
@@ -9899,7 +9913,7 @@
f) f)
;; Vario-Winkel (Vertikalbogen) auf die verfuegbaren Werte 3..51 einrasten. ;; Vario-Winkel (Vertikalbogen) auf die verfuegbaren Werte 3..51 einrasten.
(defun vfl2-snap-vfwinkel (w / liste best bd d) (defun vfl-pfad-vfwinkel-snappen (w / liste best bd d)
(setq liste (ssg-cfg-or "vario" "bogen_winkel" '(3 6 9 12 15 18 21 27 33 39 45 51))) (setq liste (ssg-cfg-or "vario" "bogen_winkel" '(3 6 9 12 15 18 21 27 33 39 45 51)))
(setq best (car liste) bd 1e9) (setq best (car liste) bd 1e9)
(foreach x liste (setq d (abs (- x w))) (if (< d bd) (setq bd d best x))) (foreach x liste (setq d (abs (- x w))) (if (< d bd) (setq bd d best x)))
@@ -9996,7 +10010,7 @@
(vfl-journal-record "NIL" nil) nil) (vfl-journal-record "NIL" nil) nil)
(progn (progn
(setq segmente (gf-analysiere-kette kette)) (setq segmente (gf-analysiere-kette kette))
(setq ecke-bad (vfl2-pruefe-eckwinkel kette ecke-tol)) (setq ecke-bad (vfl-pfad-eckwinkel-pruefen kette ecke-tol))
(if ecke-bad (if ecke-bad
(progn (progn
(vfl-meldung (ssg-textf "vfl-vwnb-alert-eckwinkel" (list (rtos ecke-bad 2 1)))) (vfl-meldung (ssg-textf "vfl-vwnb-alert-eckwinkel" (list (rtos ecke-bad 2 1))))
@@ -10013,6 +10027,7 @@
ecke-bad first-line last-line letzt-winkel ecke-bad first-line last-line letzt-winkel
aus ein soll-ende ist-ende run-typ richtn best-w aus ein soll-ende ist-ende run-typ richtn best-w
kvariante L_VF ent-fp rad3 just-open kvariante L_VF ent-fp rad3 just-open
as-vorhanden es-vorhanden alt-journal
dbg-an old-error dbg-old-error vfl-ins) dbg-an old-error dbg-old-error vfl-ins)
(princ "\n\n=========================================") (princ "\n\n=========================================")
(princ (ssg-text "vfl-vwnb-titel")) (princ (ssg-text "vfl-vwnb-titel"))
@@ -10057,27 +10072,76 @@
;; Startpunkt + Hoehe (gemeinsame Praeambel-Schale, siehe vfl-frage-punkt-hoehe). ;; Startpunkt + Hoehe (gemeinsame Praeambel-Schale, siehe vfl-frage-punkt-hoehe).
(setq startpunkt (vfl-frage-punkt-hoehe "vfl-m3-prompt-startpunkt" (setq startpunkt (vfl-frage-punkt-hoehe "vfl-m3-prompt-startpunkt"
"vfl-prompt-hoehe-startpunkt" "vfl-abgebrochen" "Starthoehe (Z, mm):")) "vfl-prompt-hoehe-startpunkt" "vfl-abgebrochen" "Starthoehe (Z, mm):"))
;; AS-Element (in Modus 3 immer gesetzt): Winkel(30/90) + Seite als EIN ;; --- ALT-JOURNAL-ERKENNUNG (einmal, gilt fuer AS UND ES) ---
;; Gruppen-Dialog. vflw-gruppe-winkel-seite-impl legt Winkel ("90"/"30") ;; Bis 2026-10-22 kannte Modus 3 weder "AS bauen?" noch "ES bauen?", und die
;; und Seite ("1"/"2") in *vflw-pending* ab - genau die Reihenfolge, die ;; ES-Frage stand am ENDE (nach dem Bau). Seither steht vor dem AS-Winkel
;; die beiden Reads unten erwarten. AS-Winkel ueber vfl-in-value (pending- ;; ein Ja/Nein und die ES-Frage VOR dem Bau - beides aendert die Reihenfolge
;; aware; vf-frage-element-winkel selbst ist es NICHT), damit der vom Dialog ;; im Journal. Ketten, die vorher gebaut wurden, muessen per Doppelklick
;; abgelegte Wert konsumiert wird statt live erneut zu fragen. ;; weiter nachbaubar bleiben; erkannt werden sie am WERT des naechsten
(if (vfl-wizard-aktiv) ;; Eintrags: dort steht im Altbestand direkt der AS-Winkel ("30"/"90"), im
(vl-catch-all-apply 'vflw-gruppe-winkel-seite-impl ;; neuen Format die Ja/Nein-Antwort ("1"/"2"). Die Wertemengen sind
(list "vf-winkel-aus-header" ;; disjunkt, die Unterscheidung also eindeutig (vfl-replay-peek-wert).
(list (ssg-text "vf-winkel-90") (ssg-text "vf-winkel-30")) ;; Live (ohne Replay-Queue) ist alt-journal immer nil = neuer Ablauf.
(list "90" "30")))) (setq alt-journal
(princ (ssg-text "vf-winkel-aus-header")) (and *vfl-replay-queue*
(princ (ssg-text "vf-winkel-90")) (= (vfl-replay-peek-art) "STR")
(princ (ssg-text "vf-winkel-30")) (member (vfl-replay-peek-wert) '("30" "90"))))
(setq *vfl-as-winkel* (if alt-journal (princ (ssg-text "vfl-m3-alt-journal")))
(vfl-in-value "STR" ;; Winkel-Globals pro Lauf zuruecksetzen (wie in Modus 1/2): ohne AS bzw.
(function (lambda () (vf-frage-element-winkel "vf-winkel-aus-header"))))) ; 30/90 vor Seite ;; ES wuerde sonst der Wert der VORHERIGEN Kette in die Block-Attribute
;; WINKEL_AS/WINKEL_ES wandern.
(setq *vfl-as-winkel* nil *vfl-es-winkel* nil)
;; AS-Element: "bauen?" + Winkel(30/90) + Seite als EIN Gruppen-Dialog -
;; dasselbe Muster wie in Modus 2 (vflw-gruppe-as-impl legt Ja/Nein, Winkel
;; "90"/"30" und Seite "1"/"2" in *vflw-pending* ab, genau in der
;; Reihenfolge, die die Reads unten erwarten). Die Ja/Nein-Frage war in
;; Modus 3 bis 2026-10-22 gar nicht vorhanden (AS wurde immer gebaut,
;; Nutzer-Wunsch).
(if alt-journal
(setq as-vorhanden t)
(progn
(if (vfl-wizard-aktiv)
(vl-catch-all-apply 'vflw-gruppe-as-impl (list "vfl-as-setzen-frage" nil)))
(princ (ssg-text "vfl-as-setzen-frage"))
(princ (ssg-text "vfl-ja"))
(princ (ssg-text "vfl-m3-as-nein"))
(setq antwort (vfl-menu (ssg-text "prompt-wahl-1-2")
(list (ssg-text "vfl-ja") (ssg-text "vfl-m3-as-nein")) 1
"vfl-as-setzen-frage"))
(setq as-vorhanden (/= antwort "2"))))
;; Winkel + Seite (setzt *vfl-as-winkel* und ueber vf-set-as-masse die
;; aus-dx/aus-dz der Variante) - gemeinsame Schale mit Modus 2.
(if as-vorhanden
(setq as-seite (vfl-frage-as-winkel-seite "gf-seite-aus-header")))
(if dbg-an (progn (dbgmsg "AS-Winkel:") (dbg '*vfl-as-winkel*) (dbgflush))) (if dbg-an (progn (dbgmsg "AS-Winkel:") (dbg '*vfl-as-winkel*) (dbgflush)))
(princ (ssg-text "vfl-vwnb-aus-seite-menu"))
(setq as-seite (if (= (vfl-in-string (ssg-text "prompt-wahl-1-2")) "2") "rechts" "links")) ;; --- ES-Element JETZT fragen, VOR dem Bau (Nutzer-Vorgabe 2026-10-22,
(vf-set-as-masse *vfl-as-winkel* as-seite) ; Masse fuer Variante ;; wie in Modus 1) ---
;; Erst damit steht der ECHTE ES-Fussabdruck fest (ein-dx/ein-dz haengen an
;; Winkel UND Seite), den die Trimmung der LETZTEN Geraden unten abzieht.
;; Vorher wurde dort ein Wert benutzt, der zu diesem Zeitpunkt noch gar
;; nicht gesetzt war: beim ersten Lauf griff der Schaetzwert
;; *vfk-as-es-fallback-dx*, bei jedem weiteren stand dort der Wert der
;; VORHERIGEN Kette. Beim Alt-Journal bleibt die Frage an ihrer alten
;; Stelle (Schritt 7), damit die Replay-Reihenfolge stimmt.
(if alt-journal
(setq es-vorhanden t) ; Frage folgt in Schritt 7
(progn
(if (vfl-wizard-aktiv)
(vl-catch-all-apply 'vflw-gruppe-as-impl (list "vfl-es-setzen-frage" nil)))
(princ (ssg-text "vfl-es-setzen-frage"))
(princ (ssg-text "vfl-ja"))
(princ (ssg-text "vfl-nein"))
(setq antwort (vfl-menu (ssg-text "prompt-wahl-1-2")
(list (ssg-text "vfl-ja") (ssg-text "vfl-nein")) 1
"vfl-es-setzen-frage"))
(setq es-vorhanden (/= antwort "2"))
(if es-vorhanden
(setq es-seite (vfl-frage-es-winkel-seite "gf-seite-ein-header"))
;; Ohne ES wird auch kein Fussabdruck reserviert - sonst bliebe die
;; letzte Gerade um Separator+ES zu kurz.
(setq ein-dx 0.0 ein-dz 0.0))))
;; --- 3. Pfad waehlen + Sortieren + Analysieren + Eck-Vorpruefung --- ;; --- 3. Pfad waehlen + Sortieren + Analysieren + Eck-Vorpruefung ---
;; vfl-in-segmente kapselt Live (ssget -> gf-sortiere-objekte -> ;; vfl-in-segmente kapselt Live (ssget -> gf-sortiere-objekte ->
@@ -10179,21 +10243,32 @@
;; --- GF-Gerade --- ;; --- GF-Gerade ---
((or (= antwort "") (= antwort "1")) ((or (= antwort "") (= antwort "1"))
(if (= run-typ "VF") ; offenen VF-Lauf schliessen (if (= run-typ "VF") ; offenen VF-Lauf schliessen
(progn (setq frame (vfl2-vf-close frame (car (frame->hz-winkel frame)))) (progn (setq frame (vfl-pfad-vf-schliessen frame (car (frame->hz-winkel frame))))
(setq run-typ nil))) (setq run-typ nil)))
(setq winkel (vfl-in-real (ssg-text "vfl-m3-prompt-gf-neigung"))) (setq winkel (vfl-in-real (ssg-text "vfl-m3-prompt-gf-neigung")))
(if (null winkel) (setq winkel *vfk-gefaelle-winkel*)) (if (null winkel) (setq winkel *vfk-gefaelle-winkel*))
(if (> winkel *vfk-gefaelle-winkel*) (if (> winkel *vfk-gefaelle-winkel*)
(progn (princ (ssg-text "vfl-m3-hinweis-gf-max")) (setq winkel *vfk-gefaelle-winkel*))) (progn (princ (ssg-text "vfl-m3-hinweis-gf-max")) (setq winkel *vfk-gefaelle-winkel*)))
;; Ohne AS beginnt die Kette direkt am Startpunkt - nur ein flacher
;; Rahmen, kein Block (wie vfl-kettenanfang-baustein in Modus 1).
;; Die Fussabdruck-Trimmung unten rechnet dann automatisch 0, weil
;; (car frame) und startpunkt zusammenfallen.
(if (null frame) (if (null frame)
(setq frame (vfl2-insert-as-gf startpunkt hz winkel as-seite))) (setq frame (if as-vorhanden
(vfl-pfad-as-gf-einfuegen startpunkt hz winkel as-seite)
(make-frame-from-dir startpunkt (hz-winkel->xu hz 0.0)))))
(setq deltaL laenge) (setq deltaL laenge)
;; erste Gerade: AS-Fussabdruck ENTLANG des Pfads exakt aus KS_AUS abziehen ;; erste Gerade: AS-Fussabdruck ENTLANG des Pfads exakt aus KS_AUS abziehen
(if (= i first-line) (if (= i first-line)
(setq deltaL (- deltaL (setq deltaL (- deltaL
(+ (* (- (car (car frame)) (car startpunkt)) (cos (* hz (/ pi 180.0)))) (+ (* (- (car (car frame)) (car startpunkt)) (cos (* hz (/ pi 180.0))))
(* (- (cadr (car frame)) (cadr startpunkt)) (sin (* hz (/ pi 180.0)))))))) (* (- (cadr (car frame)) (cadr startpunkt)) (sin (* hz (/ pi 180.0))))))))
(if (= i last-line) (setq deltaL (- deltaL *vfk-separator-laenge* ein))) ;; letzte Gerade: Platz fuer Separator + ES freihalten - aber nur,
;; wenn ueberhaupt ein ES kommt (seit 2026-10-22 abfragbar). "ein"
;; traegt jetzt den ECHTEN ein-dx der gewaehlten ES-Variante, weil
;; die ES-Frage vor dem Bau steht.
(if (and (= i last-line) es-vorhanden)
(setq deltaL (- deltaL *vfk-separator-laenge* ein)))
(setq deltaL (max *vfk-restlaenge-min-clamp* deltaL)) (setq deltaL (max *vfk-restlaenge-min-clamp* deltaL))
(setq frame (vfl-insert-gf-segment (car frame) hz deltaL winkel)) (setq frame (vfl-insert-gf-segment (car frame) hz deltaL winkel))
(vfl-acc-gf-seg (/ deltaL (cos (* winkel (/ pi 180.0)))) winkel) (vfl-acc-gf-seg (/ deltaL (cos (* winkel (/ pi 180.0)))) winkel)
@@ -10203,16 +10278,18 @@
(setq richtn (cond ((= antwort "3") "Auf") ((= antwort "4") "horizontal") (t "Ab"))) (setq richtn (cond ((= antwort "3") "Auf") ((= antwort "4") "horizontal") (t "Ab")))
(setq just-open nil) (setq just-open nil)
(if (null frame) ; AS (flach) am Kettenanfang, KS_AUS auf Pfad (if (null frame) ; AS (flach) am Kettenanfang, KS_AUS auf Pfad
(setq frame (vfl2-insert-as-vf startpunkt hz as-seite))) (setq frame (if as-vorhanden
(vfl-pfad-as-vf-einfuegen startpunkt hz as-seite)
(make-frame-from-dir startpunkt (hz-winkel->xu hz 0.0)))))
(if (not (= run-typ "VF")) ; VF-Einheit oeffnen (if (not (= run-typ "VF")) ; VF-Einheit oeffnen
(progn (setq frame (vfl2-vf-open frame hz)) (progn (setq frame (vfl-pfad-vf-oeffnen frame hz))
(setq run-typ "VF" just-open t))) (setq run-typ "VF" just-open t)))
(if (= richtn "horizontal") (if (= richtn "horizontal")
(setq best-w 0) (setq best-w 0)
(progn (progn
(setq best-w (vfl-in-int (ssg-text "vfl-vwnb-prompt-vario-winkel"))) (setq best-w (vfl-in-int (ssg-text "vfl-vwnb-prompt-vario-winkel")))
(if (null best-w) (setq best-w 3)) (if (null best-w) (setq best-w 3))
(setq best-w (vfl2-snap-vfwinkel best-w)) (setq best-w (vfl-pfad-vfwinkel-snappen best-w))
(if dbg-an (progn (dbgmsg "Vario-Winkel (gesnapt):") (dbg 'best-w) (dbgflush))))) (if dbg-an (progn (dbgmsg "Vario-Winkel (gesnapt):") (dbg 'best-w) (dbgflush)))))
(setq L_VF laenge) (setq L_VF laenge)
(if just-open (setq L_VF (- L_VF ent-fp))) ; Entry-Fussabdruck reservieren (if just-open (setq L_VF (- L_VF ent-fp))) ; Entry-Fussabdruck reservieren
@@ -10243,7 +10320,7 @@
(if (null frame) (if (null frame)
(progn (vfl-meldung (ssg-text "vfl-m3-alert-beginnt-bogen")) (exit))) (progn (vfl-meldung (ssg-text "vfl-m3-alert-beginnt-bogen")) (exit)))
(if (= run-typ "VF") ; VF-Lauf vor GF-Bogen schliessen (if (= run-typ "VF") ; VF-Lauf vor GF-Bogen schliessen
(progn (setq frame (vfl2-vf-close frame (car (frame->hz-winkel frame)))) (progn (setq frame (vfl-pfad-vf-schliessen frame (car (frame->hz-winkel frame))))
(setq run-typ nil))) (setq run-typ nil)))
(setq frame (vfl-insert-gf-bogen-block frame bwinkel bseite)) (setq frame (vfl-insert-gf-bogen-block frame bwinkel bseite))
(setq run-typ "GF")))) (setq run-typ "GF"))))
@@ -10252,16 +10329,21 @@
;; --- 7. Kettenende: offenen VF-Lauf schliessen, dann Separator + ES --- ;; --- 7. Kettenende: offenen VF-Lauf schliessen, dann Separator + ES ---
(if (null frame) (progn (princ (ssg-text "vfl-m3-nichts-gebaut")) (exit))) (if (null frame) (progn (princ (ssg-text "vfl-m3-nichts-gebaut")) (exit)))
;; Alt-Journal: dort steht die ES-Frage GENAU HIER (siehe Schritt 2) - die
;; Replay-Reihenfolge muss stimmen, also wird sie hier nachgeholt.
;; vfl-frage-es-seite nutzt intern bereits vfl-in-value/vfl-menu - wird also ;; vfl-frage-es-seite nutzt intern bereits vfl-in-value/vfl-menu - wird also
;; automatisch mitgeloggt, kein manueller dbgmsg noetig. ;; automatisch mitgeloggt, kein manueller dbgmsg noetig.
(setq es-seite (vfl-frage-es-seite nil)) (if alt-journal (setq es-seite (vfl-frage-es-seite nil)))
(if (= run-typ "VF") (if (= run-typ "VF")
(progn (progn
(setq frame (vfl2-vf-close frame (car (frame->hz-winkel frame)))) (setq frame (vfl-pfad-vf-schliessen frame (car (frame->hz-winkel frame))))
(setq frame (vfl-insert-es-element "VF" frame (car (frame->hz-winkel frame)) (if es-vorhanden
0.0 (caddr (car frame)) es-seite))) (setq frame (vfl-insert-es-element "VF" frame (car (frame->hz-winkel frame))
(setq frame (vfl-insert-es-element "GF" frame (car (frame->hz-winkel frame)) 0.0 (caddr (car frame)) es-seite))))
(if letzt-winkel letzt-winkel *vfk-gefaelle-winkel*) (caddr (car frame)) es-seite))) (if es-vorhanden
(setq frame (vfl-insert-es-element "GF" frame (car (frame->hz-winkel frame))
(if letzt-winkel letzt-winkel *vfk-gefaelle-winkel*)
(caddr (car frame)) es-seite))))
;; --- 8. Block + Journal-XDATA + Ist-Ziel-Report --- ;; --- 8. Block + Journal-XDATA + Ist-Ziel-Report ---
(setq hoehe-bis (caddr (car frame))) (setq hoehe-bis (caddr (car frame)))
@@ -10305,16 +10387,27 @@
) )
;; ============================================================ ;; ============================================================
;; MODUS 3: Pfad + Ziel-Hoehe (Randwert-Solver) - M3a ;; Z-SOLVER (vfl-zsolve-*) - Rechenkern von MODUS 2 (Pfad + Ziel-Hoehe)
;; Schritt 1+2: Geruest + Klassifizierung + Anker-Report. NOCH KEIN Bauen. ;; ============================================================
;; Details siehe doc/VarioFoerderer_Linienzug_Prinzipien.md, Abschnitt 14. ;; Gehoert zu vf-linienzug-modus2 (Menue-Modus 2), NICHT zu Modus 3 - die
;; Ueberschrift sagte bis 2026-10-22 faelschlich "MODUS 3", weil die Helfer
;; aus einer Planungsphase vor der endgueltigen Menue-Zuordnung stammen. Seit
;; der Umbenennung tragen sie darum gar keine Modus-Nummer mehr, sondern ihre
;; ROLLE: sie rechnen die Hoehen (Z) durch, waehrend der Grundriss (XY) vom
;; gezeichneten Pfad kommt. Genau diese Entkopplung macht das Randwertproblem
;; loesbar (siehe doc/VarioFoerderer_Linienzug_Prinzipien.md, Abschnitt 14.1).
;;
;; Gegenstueck: die vfl-pfad-*-Helfer weiter oben arbeiten auf dem
;; gezeichneten Pfad selbst (Eckwinkel pruefen, AS einfuegen, VF oeffnen/
;; schliessen) und werden von Modus 2 UND Modus 3 genutzt - auch sie tragen
;; deshalb bewusst keine Modus-Nummer.
;; ============================================================ ;; ============================================================
;; Signierte Z-Aenderung (mm) einer GF-Geraden: negativ = Abfall. ;; Signierte Z-Aenderung (mm) einer GF-Geraden: negativ = Abfall.
;; l-planar = XY-Planlaenge (aus Pfad), winkel = Neigung in Grad (fallend). ;; l-planar = XY-Planlaenge (aus Pfad), winkel = Neigung in Grad (fallend).
;; Ueber die Planlaenge gilt dz = -L * tan(winkel) (Fussabdruck bleibt L, ;; Ueber die Planlaenge gilt dz = -L * tan(winkel) (Fussabdruck bleibt L,
;; die 3D-Laenge waechst mit L/cos, siehe Doc 14.1). ;; die 3D-Laenge waechst mit L/cos, siehe Doc 14.1).
(defun vfl3-gf-dz (l-planar winkel / rad) (defun vfl-zsolve-gf-dz (l-planar winkel / rad)
(setq rad (* (float winkel) (/ pi 180.0))) (setq rad (* (float winkel) (/ pi 180.0)))
(- (* (float l-planar) (/ (sin rad) (cos rad))))) (- (* (float l-planar) (/ (sin rad) (cos rad)))))
@@ -10323,10 +10416,10 @@
;; GF-Bogen -> dz aus gf-bogen-masse (Block-KS) ;; GF-Bogen -> dz aus gf-bogen-masse (Block-KS)
;; Vario-Kurve -> 0 (auf 0 Grad geflacht) ;; Vario-Kurve -> 0 (auf 0 Grad geflacht)
;; VF-Gerade -> nil (unbekannt = Teil der Bruecke) ;; VF-Gerade -> nil (unbekannt = Teil der Bruecke)
(defun vfl3-seg-dz (e) (defun vfl-zsolve-seg-dz (e)
(cond (cond
((= (car e) "Linie") ((= (car e) "Linie")
(if (= (nth 3 e) "GF") (vfl3-gf-dz (caddr e) (nth 4 e)) nil)) (if (= (nth 3 e) "GF") (vfl-zsolve-gf-dz (caddr e) (nth 4 e)) nil))
((= (car e) "Bogen") ((= (car e) "Bogen")
(if (= (nth 5 e) "Vario-Kurve") (if (= (nth 5 e) "Vario-Kurve")
0.0 0.0
@@ -10340,7 +10433,12 @@
;; ihre Laenge variiert (das ist der Ausgleich, siehe Doc 14.3). ;; ihre Laenge variiert (das ist der Ausgleich, siehe Doc 14.3).
;; dH-signiert: negativ = Auf (steigt), positiv = Ab (faellt). ;; dH-signiert: negativ = Auf (steigt), positiv = Ab (faellt).
;; Rueckgabe: (winkel L_GF L_VF richtung) oder nil (kein passender Winkel). ;; Rueckgabe: (winkel L_GF L_VF richtung) oder nil (kein passender Winkel).
(defun vfl3-solve-bruecke (span dH-signiert extra-fest / ;;
;; HINWEIS: derzeit von NIEMANDEM aufgerufen - der Bau-Pfad loest die Bruecke
;; ueber vfl-zsolve-winkel-waehlen. Beim Umbenennen 2026-10-22 bewusst stehen
;; gelassen statt geloescht (gehoert in ein Tote-Code-Review, nicht in eine
;; Umbenennung).
(defun vfl-zsolve-bruecke (span dH-signiert extra-fest /
o-adx o-adz o-eix o-eiz richtung fh res winkel) o-adx o-adz o-eix o-eiz richtung fh res winkel)
(setq richtung (if (< dH-signiert 0) "Auf" "Ab")) (setq richtung (if (< dH-signiert 0) "Auf" "Ab"))
(setq fh (+ (if (boundp '*vfl-feste-horizontal*) *vfl-feste-horizontal* 1300.0) (setq fh (+ (if (boundp '*vfl-feste-horizontal*) *vfl-feste-horizontal* 1300.0)
@@ -10356,7 +10454,7 @@
;; GF-Bogen-dz, wenn der Bogen bei Neigung theta (Grad) KS-gekettet wird: ;; GF-Bogen-dz, wenn der Bogen bei Neigung theta (Grad) KS-gekettet wird:
;; der lokale (dx,dz) des Blocks wird um theta gekippt. ;; der lokale (dx,dz) des Blocks wird um theta gekippt.
;; Z-Anteil = -dx*sin(theta) + dz*cos(theta) (negativ = Abfall) ;; Z-Anteil = -dx*sin(theta) + dz*cos(theta) (negativ = Abfall)
(defun vfl3-bogen-dz-incl (bwinkel bseite theta / m dx dz rad) (defun vfl-zsolve-bogen-dz-incl (bwinkel bseite theta / m dx dz rad)
(setq m (gf-bogen-masse bwinkel bseite) dx (car m) dz (cadr m)) (setq m (gf-bogen-masse bwinkel bseite) dx (car m) dz (cadr m))
(setq rad (* (float theta) (/ pi 180.0))) (setq rad (* (float theta) (/ pi 180.0)))
(+ (* (- dx) (sin rad)) (* dz (cos rad)))) (+ (* (- dx) (sin rad)) (* dz (cos rad))))
@@ -10366,7 +10464,7 @@
;; ES-Eigen-dz. Spiegelt den tatsaechlichen Bau (Trimmung der letzten Geraden um ;; ES-Eigen-dz. Spiegelt den tatsaechlichen Bau (Trimmung der letzten Geraden um
;; 300+ein-fp, GF-Bogen bei Neigung). Eintritts-Neigung = 3 Grad (die Bruecke ;; 300+ein-fp, GF-Bogen bei Neigung). Eintritts-Neigung = 3 Grad (die Bruecke
;; endet mit GF2 auf 3 Grad). So wird die Junction-Hoehe exakt statt geschaetzt. ;; endet mit GF2 auf 3 Grad). So wird die Junction-Hoehe exakt statt geschaetzt.
(defun vfl3-dback (plan start-idx n last-idx ein-fp / i seg drop inc w dL rad) (defun vfl-zsolve-rueckanker (plan start-idx n last-idx ein-fp / i seg drop inc w dL rad)
(setq drop 0.0 inc *vfk-gefaelle-winkel* i start-idx) (setq drop 0.0 inc *vfk-gefaelle-winkel* i start-idx)
(while (< i n) (while (< i n)
(setq seg (nth i plan)) (setq seg (nth i plan))
@@ -10380,7 +10478,7 @@
(setq inc w)) (setq inc w))
((= (car seg) "Bogen") ((= (car seg) "Bogen")
(if (= (nth 5 seg) "GF-Bogen") (if (= (nth 5 seg) "GF-Bogen")
(setq drop (- drop (vfl3-bogen-dz-incl (nth 3 seg) (nth 4 seg) inc)))))) (setq drop (- drop (vfl-zsolve-bogen-dz-incl (nth 3 seg) (nth 4 seg) inc))))))
(setq i (1+ i))) (setq i (1+ i)))
;; Auslauf-Separator (300 mm bei aktueller Neigung inc) + ES-Eigen-dz ;; Auslauf-Separator (300 mm bei aktueller Neigung inc) + ES-Eigen-dz
(setq rad (* (float inc) (/ pi 180.0))) (setq rad (* (float inc) (/ pi 180.0)))
@@ -10394,7 +10492,7 @@
;; Horizontal-Mitte-Koerper zwei 3-Grad-Uebergangsboegen. Einbau-Rotationen wie ;; Horizontal-Mitte-Koerper zwei 3-Grad-Uebergangsboegen. Einbau-Rotationen wie
;; in vfs-vf-koerper; Bogen-dz_eff = -dx*sin(rot) + dz_roh*cos(rot) (am Log ;; in vfs-vf-koerper; Bogen-dz_eff = -dx*sin(rot) + dz_roh*cos(rot) (am Log
;; verifiziert). So ist die Hoehe rein rechnerisch bestimmt -> Kletterlaenge folgt. ;; verifiziert). So ist die Hoehe rein rechnerisch bestimmt -> Kletterlaenge folgt.
(defun vfl3-einheit-fix-dz (w n-climb n-hor gf1 richtung / (defun vfl-zsolve-einheit-fix-dz (w n-climb n-hor gf1 richtung /
pi180 rad3 s3 tot m1 m2 r1 r2 dz1 dz2) pi180 rad3 s3 tot m1 m2 r1 r2 dz1 dz2)
(setq pi180 (/ pi 180.0) rad3 (* *vfk-gefaelle-winkel* pi180) s3 (sin rad3) tot 0.0) (setq pi180 (/ pi 180.0) rad3 (* *vfk-gefaelle-winkel* pi180) s3 (sin rad3) tot 0.0)
;; feste 3-Grad-Teile senken immer ab (GF1 + Separator + Umlenk + Motor) ;; feste 3-Grad-Teile senken immer ab (GF1 + Separator + Umlenk + Motor)
@@ -10420,7 +10518,7 @@
;; + je Kletterer die zwei Boegen + je Horizontal-Mitte-Koerper die zwei ;; + je Kletterer die zwei Boegen + je Horizontal-Mitte-Koerper die zwei
;; 3-Grad-Boegen. dx_eff = dx*cos(rot) + dz_roh*sin(rot) (am Log verifiziert). ;; 3-Grad-Boegen. dx_eff = dx*cos(rot) + dz_roh*sin(rot) (am Log verifiziert).
;; Dient der Winkelwahl: Fussabdruck + Kletter-Planlaenge soll die Lauflaenge treffen. ;; Dient der Winkelwahl: Fussabdruck + Kletter-Planlaenge soll die Lauflaenge treffen.
(defun vfl3-einheit-fix-dx (w n-climb n-hor gf1 richtung / (defun vfl-zsolve-einheit-fix-dx (w n-climb n-hor gf1 richtung /
pi180 rad3 tot m1 m2 r1 r2 dx1 dx2) pi180 rad3 tot m1 m2 r1 r2 dx1 dx2)
(setq pi180 (/ pi 180.0) rad3 (* *vfk-gefaelle-winkel* pi180) tot 0.0) (setq pi180 (/ pi 180.0) rad3 (* *vfk-gefaelle-winkel* pi180) tot 0.0)
(setq tot (* (+ (float gf1) *vfk-separator-laenge* *vfk-stations-laenge* *vfk-stations-laenge*) (cos rad3))) ; Stationen planar (setq tot (* (+ (float gf1) *vfk-separator-laenge* *vfk-stations-laenge* *vfk-stations-laenge*) (cos rad3))) ; Stationen planar
@@ -10440,13 +10538,13 @@
;; Uebergang von der 3-Grad-Kletterbasis in die FLACHE Zone (0 Grad): EIN auf_3-Bogen ;; Uebergang von der 3-Grad-Kletterbasis in die FLACHE Zone (0 Grad): EIN auf_3-Bogen
;; (Rotation 3 Grad). Rueckgabe: neuer Punkt. ;; (Rotation 3 Grad). Rueckgabe: neuer Punkt.
(defun vfl3-flach-ein (pt hz / m) (defun vfl-zsolve-flach-ein (pt hz / m)
(setq m (get-bogen-mass bogen-auf 3)) (setq m (get-bogen-mass bogen-auf 3))
(insert-rotated-block-with-ks "Vario_Bogen_auf_3_TEF_rechts" pt 3 (car m) (caddr m) hz)) (insert-rotated-block-with-ks "Vario_Bogen_auf_3_TEF_rechts" pt 3 (car m) (caddr m) hz))
;; Uebergang aus der flachen Zone (0 Grad) zurueck auf 3-Grad-Basis: EIN ab_3-Bogen ;; Uebergang aus der flachen Zone (0 Grad) zurueck auf 3-Grad-Basis: EIN ab_3-Bogen
;; (Rotation 0 Grad). Rueckgabe: neuer Punkt. ;; (Rotation 0 Grad). Rueckgabe: neuer Punkt.
(defun vfl3-flach-aus (pt hz / m) (defun vfl-zsolve-flach-aus (pt hz / m)
(setq m (get-bogen-mass bogen-ab 3)) (setq m (get-bogen-mass bogen-ab 3))
(insert-rotated-block-with-ks "Vario_Bogen_ab_3_TEF_rechts" pt 0 (car m) (caddr m) hz)) (insert-rotated-block-with-ks "Vario_Bogen_ab_3_TEF_rechts" pt 0 (car m) (caddr m) hz))
@@ -10454,7 +10552,7 @@
;; Mittige Bruecke -> KEIN terminales AS/ES (Masse auf 0, Save/Restore). feste = fester ;; Mittige Bruecke -> KEIN terminales AS/ES (Masse auf 0, Save/Restore). feste = fester
;; Horizontal-Anteil des Kletter-Segments (Umlenk+Separator = 800; Motor sitzt spaeter ;; Horizontal-Anteil des Kletter-Segments (Umlenk+Separator = 800; Motor sitzt spaeter
;; am Kettenende). Rueckgabe: (winkel L_GF L_VF richtung) oder nil. ;; am Kettenende). Rueckgabe: (winkel L_GF L_VF richtung) oder nil.
(defun vfl3-waehle-winkel (span dH-signiert feste / (defun vfl-zsolve-winkel-waehlen (span dH-signiert feste /
o-adx o-adz o-eix o-eiz richtung res wahl) o-adx o-adz o-eix o-eiz richtung res wahl)
(setq richtung (if (< dH-signiert 0) "Auf" "Ab")) (setq richtung (if (< dH-signiert 0) "Auf" "Ab"))
(setq o-adx aus-dx o-adz aus-dz o-eix ein-dx o-eiz ein-dz) (setq o-adx aus-dx o-adz aus-dz o-eix ein-dx o-eiz ein-dz)
@@ -10466,14 +10564,14 @@
;; ES-Element-Fussabdruck ENTLANG/QUER zu einer Fahrtrichtung seg-hz (Welt- ;; ES-Element-Fussabdruck ENTLANG/QUER zu einer Fahrtrichtung seg-hz (Welt-
;; Komponenten), aus der REALEN Blockgeometrie (vf-element-ks-info) berechnet. ;; Komponenten), aus der REALEN Blockgeometrie (vf-element-ks-info) berechnet.
;; Kernstueck von vfl3-es-fueller, hier ausgelagert, damit AUCH die feste-vf- ;; Kernstueck von vfl-zsolve-es-fueller, hier ausgelagert, damit AUCH die feste-vf-
;; Berechnung in vf-linienzug-modus2 (Fall hor-pairs=0, OHNE flache ;; Berechnung in vf-linienzug-modus2 (Fall hor-pairs=0, OHNE flache
;; Zone/vfl3-es-fueller) denselben Wert nutzen kann, statt den ES-Laengsanteil ;; Zone/vfl-zsolve-es-fueller) denselben Wert nutzen kann, statt den ES-Laengsanteil
;; im Laengenbudget des Solvers stillschweigend zu vergessen (realer Bug: ;; im Laengenbudget des Solvers stillschweigend zu vergessen (realer Bug:
;; Kette ueberschoss um ungefaehr along-es+Separator, siehe dortiger Kommentar). ;; Kette ueberschoss um ungefaehr along-es+Separator, siehe dortiger Kommentar).
;; Rueckgabe: (list along-es perp-es) oder nil, wenn der Block nicht lesbar ;; Rueckgabe: (list along-es perp-es) oder nil, wenn der Block nicht lesbar
;; ist (Aufrufer faellt dann auf eine grobe Naeherung zurueck). ;; ist (Aufrufer faellt dann auf eine grobe Naeherung zurueck).
(defun vfl3-es-vektor (es-block seg-hz / info theta dpx dpy npx npy phi vx vy vwx vwy) (defun vfl-zsolve-es-vektor (es-block seg-hz / info theta dpx dpy npx npy phi vx vy vwx vwy)
(setq info (vf-element-ks-info es-block)) (setq info (vf-element-ks-info es-block))
(if (null info) (if (null info)
nil nil
@@ -10497,10 +10595,10 @@
;; KS_AUS = pt + (fill + C)*dp + perp-es*np ;; KS_AUS = pt + (fill + C)*dp + perp-es*np
;; C = 196 (ab_3) + (Motor 500 + GF2 + Sep 300)*cos3 + along-es ;; C = 196 (ab_3) + (Motor 500 + GF2 + Sep 300)*cos3 + along-es
;; Achse u_a = seg-hz + (KS_AUS.xu - KS_EIN.xu)_Block ; (Endpunkt-KS_AUS)*n_a=0 -> fill ;; Achse u_a = seg-hz + (KS_AUS.xu - KS_EIN.xu)_Block ; (Endpunkt-KS_AUS)*n_a=0 -> fill
(defun vfl3-es-fueller (pt endp seg-hz es-block gf2 rad3 / (defun vfl-zsolve-es-fueller (pt endp seg-hz es-block gf2 rad3 /
vek theta dpx dpy npx npy info vek theta dpx dpy npx npy info
along-es perp-es ua na-x na-y cc dp-na np-na ep-na) along-es perp-es ua na-x na-y cc dp-na np-na ep-na)
(setq vek (vfl3-es-vektor es-block seg-hz)) (setq vek (vfl-zsolve-es-vektor es-block seg-hz))
(if (null vek) (if (null vek)
(- (+ (* (- (car endp) (car pt)) (cos (* seg-hz (/ pi 180.0)))) (- (+ (* (- (car endp) (car pt)) (cos (* seg-hz (/ pi 180.0))))
(* (- (cadr endp) (cadr pt)) (sin (* seg-hz (/ pi 180.0))))) (* (- (cadr endp) (cadr pt)) (sin (* seg-hz (/ pi 180.0)))))
@@ -10785,14 +10883,14 @@
;; Vorwaerts: Start-Z durch alle Front-Segmente (Index < vf-start). ;; Vorwaerts: Start-Z durch alle Front-Segmente (Index < vf-start).
(setq z-front (float start-hoehe) i 0) (setq z-front (float start-hoehe) i 0)
(while (< i vf-start) (while (< i vf-start)
(setq dz (vfl3-seg-dz (nth i plan))) (setq dz (vfl-zsolve-seg-dz (nth i plan)))
(if dz (setq z-front (+ z-front dz))) (if dz (setq z-front (+ z-front dz)))
(setq i (1+ i))) (setq i (1+ i)))
;; Rueckwaerts: Ziel-Z durch alle Back-Segmente (Index > vf-ende). ;; Rueckwaerts: Ziel-Z durch alle Back-Segmente (Index > vf-ende).
;; Vorwaerts gilt Z_next = Z_prev + dz -> rueckwaerts Z_prev = Z_next - dz. ;; Vorwaerts gilt Z_next = Z_prev + dz -> rueckwaerts Z_prev = Z_next - dz.
(setq z-junction (float end-hoehe) i (1- n)) (setq z-junction (float end-hoehe) i (1- n))
(while (> i vf-ende) (while (> i vf-ende)
(setq dz (vfl3-seg-dz (nth i plan))) (setq dz (vfl-zsolve-seg-dz (nth i plan)))
(if dz (setq z-junction (- z-junction dz))) (if dz (setq z-junction (- z-junction dz)))
(setq i (1- i))) (setq i (1- i)))
@@ -10862,7 +10960,7 @@
;; Back-Lauf danach) - sonst bleibt die Steuerung komplett unveraendert ;; Back-Lauf danach) - sonst bleibt die Steuerung komplett unveraendert
;; (es-vorhanden aus der Upfront-Frage, Motorstation immer gebaut). "Ohne ;; (es-vorhanden aus der Upfront-Frage, Motorstation immer gebaut). "Ohne
;; Motorstation" muss VOR der Phase-B2-Zielhoehen-Berechnung feststehen, ;; Motorstation" muss VOR der Phase-B2-Zielhoehen-Berechnung feststehen,
;; da sie die Separator/ES-Naeherung in vfl3-dback wieder aufhebt. ;; da sie die Separator/ES-Naeherung in vfl-zsolve-rueckanker wieder aufhebt.
(setq m2-offenes-ende nil) (setq m2-offenes-ende nil)
(if (= vf-ende (1- n)) (if (= vf-ende (1- n))
(progn (progn
@@ -10947,7 +11045,7 @@
;; (car frame) bereits gleich startpunkt ist. ;; (car frame) bereits gleich startpunkt ist.
(if (null frame) (if (null frame)
(setq frame (if as-vorhanden (setq frame (if as-vorhanden
(vfl2-insert-as-gf startpunkt hz winkel as-seite) (vfl-pfad-as-gf-einfuegen startpunkt hz winkel as-seite)
(make-frame-from-dir startpunkt (hz-winkel->xu hz 0.0))))) (make-frame-from-dir startpunkt (hz-winkel->xu hz 0.0)))))
(setq deltaL (caddr seg)) (setq deltaL (caddr seg))
;; erste Gerade: AS-Fussabdruck ENTLANG des Pfads exakt aus KS_AUS abziehen ;; erste Gerade: AS-Fussabdruck ENTLANG des Pfads exakt aus KS_AUS abziehen
@@ -10995,17 +11093,17 @@
(setq hz (cadr (nth vf-start plan))) (setq hz (cadr (nth vf-start plan)))
(if (null frame) (if (null frame)
(setq frame (if as-vorhanden (setq frame (if as-vorhanden
(vfl2-insert-as-vf startpunkt hz as-seite) (vfl-pfad-as-vf-einfuegen startpunkt hz as-seite)
(make-frame-from-dir startpunkt (hz-winkel->xu hz 0.0))))) (make-frame-from-dir startpunkt (hz-winkel->xu hz 0.0)))))
(setq z-front (caddr (car frame))) (setq z-front (caddr (car frame)))
;; --- B2: Back-Abstieg -> Junction; Kletterer + Horizontal-Mitte bestimmen --- ;; --- B2: Back-Abstieg -> Junction; Kletterer + Horizontal-Mitte bestimmen ---
(setq z-junction (+ (float end-hoehe) (setq z-junction (+ (float end-hoehe)
(vfl3-dback plan (1+ vf-ende) n last-line ein))) (vfl-zsolve-rueckanker plan (1+ vf-ende) n last-line ein)))
;; Offenes Ende (kein Motor/Separator/ES danach) ODER Motor+GF2 OHNE ES ;; Offenes Ende (kein Motor/Separator/ES danach) ODER Motor+GF2 OHNE ES
;; danach (Lauf-Abschluss "Motorstation", es-vorhanden nil - Motor selbst ;; danach (Lauf-Abschluss "Motorstation", es-vorhanden nil - Motor selbst
;; ist bereits ueber dH-adj/*vfk-bruecke-korrektur* separat eingerechnet, ;; ist bereits ueber dH-adj/*vfk-bruecke-korrektur* separat eingerechnet,
;; siehe Phase B weiter unten): vfl3-dback's Tail-Naeherung (reserviert ;; siehe Phase B weiter unten): vfl-zsolve-rueckanker's Tail-Naeherung (reserviert
;; IMMER einen Separator+ES-Fussabdruck) ist in BEIDEN Faellen falsch - die ;; IMMER einen Separator+ES-Fussabdruck) ist in BEIDEN Faellen falsch - die
;; Zielhoehe fuer den Loeser ist exakt end-hoehe. Realer Bug, bis dahin nur ;; Zielhoehe fuer den Loeser ist exakt end-hoehe. Realer Bug, bis dahin nur
;; fuer m2-offenes-ende behandelt: "Motorstation ohne ES" fiel durch dieselbe ;; fuer m2-offenes-ende behandelt: "Motorstation ohne ES" fiel durch dieselbe
@@ -11077,7 +11175,7 @@
(setq feste-vf entry-fixed (setq feste-vf entry-fixed
dH-adj (- dH-bruecke (+ (* *vfk-stations-laenge* (sin rad3v)) *vfk-bruecke-korrektur*))) ; Motor + auf_3/ab_3 dH-adj (- dH-bruecke (+ (* *vfk-stations-laenge* (sin rad3v)) *vfk-bruecke-korrektur*))) ; Motor + auf_3/ab_3
(progn (progn
;; OHNE flache Zone gibt es KEIN vfl3-es-fueller, das den Separator+ES- ;; OHNE flache Zone gibt es KEIN vfl-zsolve-es-fueller, das den Separator+ES-
;; Laengsanteil selbststaendig gegen den echten Zielpunkt korrigiert - ;; Laengsanteil selbststaendig gegen den echten Zielpunkt korrigiert -
;; beide fehlten hier bislang komplett im Laengenbudget des Solvers ;; beide fehlten hier bislang komplett im Laengenbudget des Solvers
;; (realer Bug: die Kette ueberschoss um ungefaehr Separator+along-es, ;; (realer Bug: die Kette ueberschoss um ungefaehr Separator+along-es,
@@ -11085,7 +11183,7 @@
;; WICHTIG: NUR die Laenge korrigieren, NICHT ueber feste-vf/dH-adj - ;; WICHTIG: NUR die Laenge korrigieren, NICHT ueber feste-vf/dH-adj -
;; feste-vf fliesst in berechne-alle-winkel per sin(3°) AUCH in die ;; feste-vf fliesst in berechne-alle-winkel per sin(3°) AUCH in die
;; Hoehenbilanz ein, waehrend die reale Hoehe von Separator+ES bereits ;; Hoehenbilanz ein, waehrend die reale Hoehe von Separator+ES bereits
;; VOLLSTAENDIG ueber z-junction/vfl3-dback erfasst ist (Separator dort ;; VOLLSTAENDIG ueber z-junction/vfl-zsolve-rueckanker erfasst ist (Separator dort
;; per tan(3°), ES-Eigenhoehe per ein-dz - siehe dortiger Kommentar). ;; per tan(3°), ES-Eigenhoehe per ein-dz - siehe dortiger Kommentar).
;; Ueber feste-vf haette das die Hoehe ein zweites Mal (und fuer ;; Ueber feste-vf haette das die Hoehe ein zweites Mal (und fuer
;; along-es sogar physikalisch falsch, da along-es keinen sin(3°)- ;; along-es sogar physikalisch falsch, da along-es keinen sin(3°)-
@@ -11095,7 +11193,7 @@
dH-adj dH-bruecke) dH-adj dH-bruecke)
(if es-vorhanden (if es-vorhanden
(progn (progn
(setq es-vek-fix (vfl3-es-vektor (setq es-vek-fix (vfl-zsolve-es-vektor
(strcat "ES_Element_" (vfl-es-winkel) "_" es-seite) (strcat "ES_Element_" (vfl-es-winkel) "_" es-seite)
(cadr (nth vf-ende plan)))) (cadr (nth vf-ende plan))))
(setq es-along-fix (setq es-along-fix
@@ -11107,7 +11205,7 @@
;; es-along-fix (reine Laenge, siehe oben) NUR aus dem Laengenbudget (span) ;; es-along-fix (reine Laenge, siehe oben) NUR aus dem Laengenbudget (span)
;; abziehen - NICHT aus feste-vf, sonst floss es faelschlich ueber sin(3°) ;; abziehen - NICHT aus feste-vf, sonst floss es faelschlich ueber sin(3°)
;; auch in die Hoehenbilanz ein (siehe Kommentar oben). ;; auch in die Hoehenbilanz ein (siehe Kommentar oben).
(setq wahl3 (vfl3-waehle-winkel (- climber-span es-along-fix) dH-adj feste-vf)) (setq wahl3 (vfl-zsolve-winkel-waehlen (- climber-span es-along-fix) dH-adj feste-vf))
(if (null wahl3) (if (null wahl3)
(progn (progn
;; Stufe 2: KEIN Tabellenwinkel passt (der/die Kletterer sind bei JEDER ;; Stufe 2: KEIN Tabellenwinkel passt (der/die Kletterer sind bei JEDER
@@ -11186,7 +11284,7 @@
(cond (cond
;; --- Kletterer (geneigt, 3-Grad-Basis) --- ;; --- Kletterer (geneigt, 3-Grad-Basis) ---
((and (= (car seg) "Linie") (member i climbers)) ((and (= (car seg) "Linie") (member i climbers))
(if flat-p (progn (setq pt (vfl3-flach-aus pt seg-hz)) (setq flat-p nil))) (if flat-p (progn (setq pt (vfl-zsolve-flach-aus pt seg-hz)) (setq flat-p nil)))
(setq this-lvf (max *vfk-restlaenge-min-clamp* (* br-lvf (/ (caddr seg) climber-span)))) (setq this-lvf (max *vfk-restlaenge-min-clamp* (* br-lvf (/ (caddr seg) climber-span))))
(setq pt (vfs-vf-koerper pt br-richtn br-winkel this-lvf seg-hz)) (setq pt (vfs-vf-koerper pt br-richtn br-winkel this-lvf seg-hz))
(vfl-acc-vf-seg br-richtn br-winkel this-lvf) (vfl-acc-vf-seg br-richtn br-winkel this-lvf)
@@ -11195,7 +11293,7 @@
((= (car seg) "Linie") ((= (car seg) "Linie")
(setq flat-zone-erste (not flat-p)) (setq flat-zone-erste (not flat-p))
(if (not flat-p) (if (not flat-p)
(progn (setq pt (vfl3-flach-ein pt letzt-koerper-hz)) (setq flat-p t) (progn (setq pt (vfl-zsolve-flach-ein pt letzt-koerper-hz)) (setq flat-p t)
;; Fueller-A: der im Kletter-Segment durch 1/2 GF1 frei werdende Platz ;; Fueller-A: der im Kletter-Segment durch 1/2 GF1 frei werdende Platz
(if (and (> filler-A-len 0.1) (not filler-a-done)) (if (and (> filler-A-len 0.1) (not filler-a-done))
(progn (vf-vfhoehe-merke pt) (progn (vf-vfhoehe-merke pt)
@@ -11215,7 +11313,7 @@
;; nichts mehr gebaut wird - Fueller zielt direkt auf den Endpunkt. ;; nichts mehr gebaut wird - Fueller zielt direkt auf den Endpunkt.
(setq fill-len (setq fill-len
(if es-vorhanden (if es-vorhanden
(vfl3-es-fueller pt endpunkt seg-hz (vfl-zsolve-es-fueller pt endpunkt seg-hz
(strcat "ES_Element_" (vfl-es-winkel) "_" es-seite) (strcat "ES_Element_" (vfl-es-winkel) "_" es-seite)
br-gf2-exp rad3v) br-gf2-exp rad3v)
(- (+ (* (- (car endpunkt) (car pt)) (cos (* seg-hz (/ pi 180.0)))) (- (+ (* (- (car endpunkt) (car pt)) (cos (* seg-hz (/ pi 180.0))))
@@ -11242,7 +11340,7 @@
;; --- Vario-Kurve (flach, direkt bei 0 Grad) --- ;; --- Vario-Kurve (flach, direkt bei 0 Grad) ---
((= (car seg) "Bogen") ((= (car seg) "Bogen")
(if (not flat-p) (if (not flat-p)
(progn (setq pt (vfl3-flach-ein pt letzt-koerper-hz)) (setq flat-p t) (progn (setq pt (vfl-zsolve-flach-ein pt letzt-koerper-hz)) (setq flat-p t)
;; Fueller-A: der im Kletter-Segment durch 1/2 GF1 frei werdende Platz ;; Fueller-A: der im Kletter-Segment durch 1/2 GF1 frei werdende Platz
(if (and (> filler-A-len 0.1) (not filler-a-done)) (if (and (> filler-A-len 0.1) (not filler-a-done))
(progn (vf-vfhoehe-merke pt) (progn (vf-vfhoehe-merke pt)
@@ -11264,13 +11362,14 @@
;; Rueck-Uebergang auf 3 Grad, KEINE Motorstation/GF2. ;; Rueck-Uebergang auf 3 Grad, KEINE Motorstation/GF2.
(setq frame (make-frame-from-dir pt (hz-winkel->xu letzt-koerper-hz 0.0))) (setq frame (make-frame-from-dir pt (hz-winkel->xu letzt-koerper-hz 0.0)))
(progn (progn
(if flat-p (progn (setq pt (vfl3-flach-aus pt letzt-koerper-hz)) (setq flat-p nil))) ; zurueck 3 Grad (if flat-p (progn (setq pt (vfl-zsolve-flach-aus pt letzt-koerper-hz)) (setq flat-p nil))) ; zurueck 3 Grad
;; Motorstation + GF2 in EINEM Schritt mit dem im Solve (vfl3-waehle- ;; Motorstation + GF2 in EINEM Schritt mit dem im Solve
;; winkel/GF-Verteilung, siehe br-gf2-exp oben) bereits geplanten Wert - ;; (vfl-zsolve-winkel-waehlen/GF-Verteilung, siehe br-gf2-exp oben)
;; bereits geplanten Wert -
;; NICHT mehr unabhaengig aus der gemessenen Resthoehe neu herleiten. ;; NICHT mehr unabhaengig aus der gemessenen Resthoehe neu herleiten.
;; Die alte Zwei-Loesungen-Variante (Motor mit L_GF2=0.0, GF2 danach aus ;; Die alte Zwei-Loesungen-Variante (Motor mit L_GF2=0.0, GF2 danach aus
;; z-aftermotor/z-junction gemessen) widersprach der Fueller-Position ;; z-aftermotor/z-junction gemessen) widersprach der Fueller-Position
;; (fill-len, vfl3-es-fueller), die bereits br-gf2-exp als GF2-Laenge ;; (fill-len, vfl-zsolve-es-fueller), die bereits br-gf2-exp als GF2-Laenge
;; angenommen hatte - jede Differenz zwischen den beiden GF2-Werten ;; angenommen hatte - jede Differenz zwischen den beiden GF2-Werten
;; verschob das Kettenende entlang der Fahrtrichtung (realer Bug: ;; verschob das Kettenende entlang der Fahrtrichtung (realer Bug:
;; "letztes Segment baut zu lang"). Identische Fehlerklasse wie der ;; "letztes Segment baut zu lang"). Identische Fehlerklasse wie der
doc/plan/vf-parameter-struct-analyse.md
+1 -1
View File
@@ -60,7 +60,7 @@ Erweiterung (AutoLISP-Konvention: Alist statt echtem Struct):
| `vfl-modus-abbruch-sichern` | vf_linienzug.lsp | 9 | | `vfl-modus-abbruch-sichern` | vf_linienzug.lsp | 9 |
| `vf-winkel-solve` | vf_core.lsp | 8 | | `vf-winkel-solve` | vf_core.lsp | 8 |
| `vfs-mitte-teil`, `vfl-vf-einheit`, `vfl-vf-einheit-abschluss` | standard/linienzug | je 7 | | `vfs-mitte-teil`, `vfl-vf-einheit`, `vfl-vf-einheit-abschluss` | standard/linienzug | je 7 |
| `vfs-vf-koerper`, `vfl-insert-es-element`, `vfl3-es-fueller` | standard/linienzug | je 5-6 | | `vfs-vf-koerper`, `vfl-insert-es-element`, `vfl-zsolve-es-fueller` | standard/linienzug | je 5-6 |
| die vier `insert-hz-*`-Funktionen | vf_etage.lsp | je 4-6 | | die vier `insert-hz-*`-Funktionen | vf_etage.lsp | je 4-6 |
## Struct-Kandidaten ## Struct-Kandidaten
doc/todo/modus2-achsenweise-bilanz.md
+1 -1
View File
@@ -44,7 +44,7 @@ ganze Hoehe traegt, und rechnet die geneigte Laenge skalar:
```lisp ```lisp
;; vf_linienzug.lsp:9990 - Solver bekommt die SKALARE Spanne ;; vf_linienzug.lsp:9990 - Solver bekommt die SKALARE Spanne
(setq wahl3 (vfl3-waehle-winkel climber-span dH-adj feste-vf)) (setq wahl3 (vfl-zsolve-winkel-waehlen climber-span dH-adj feste-vf))
;; feste-vf = Umlenk + Separator (+ Motor) -- ein fester Fussabdruck ;; feste-vf = Umlenk + Separator (+ Motor) -- ein fester Fussabdruck
;; vf_linienzug.lsp:10070 - Kletterer bekommt br-lvf proportional ;; vf_linienzug.lsp:10070 - Kletterer bekommt br-lvf proportional
doc/todo/plan-vf-interactive.md
+6 -3
View File
@@ -149,8 +149,11 @@ Modus-uebergreifende Blocker:
- **`ATTREQ`/`ATTDIA`**: ohne `0` fragt das `(command "_.INSERT" ...)` in den - **`ATTREQ`/`ATTDIA`**: ohne `0` fragt das `(command "_.INSERT" ...)` in den
Einfuegeprimitiven nach Attributwerten - der wahrscheinlichste Haenger. Einfuegeprimitiven nach Attributwerten - der wahrscheinlichste Haenger.
Namensfalle: die `vfl3-*`-Helfer (:5093-5276) gehoeren zu **Modus 2**, die Namensschema (seit 2026-10-22 rollenbasiert statt nach Modus-Nummer, die
`vfl2-*`-Helfer (:4703-4804) zu **Modus 3**. frueheren Praefixe `vfl3-`/`vfl2-` waren zur Menue-Nummerierung vertauscht):
die `vfl-zsolve-*`-Helfer rechnen die Hoehen durch und gehoeren zu **Modus 2**;
die `vfl-pfad-*`-Helfer arbeiten auf dem gezeichneten Pfad und werden von
**Modus 2 UND Modus 3** genutzt.
--- ---
@@ -695,7 +698,7 @@ Architektur, nicht Funktion.
### Ausdruecklich nicht anfassen ### Ausdruecklich nicht anfassen
`vf-linienzug-modus3` + alle `vfl2-*`; die `vfl-in-*`-Wrapper und `vfl-menu*`; `vf-linienzug-modus3` + alle `vfl-pfad-*`; die `vfl-in-*`-Wrapper und `vfl-menu*`;
`vfl-entry->string` und das XDATA-Layout/die Marker; **alle Journal-Konsumenten** `vfl-entry->string` und das XDATA-Layout/die Marker; **alle Journal-Konsumenten**
(brauchen sie Aenderungen, ist die Invariante gebrochen - das ist der (brauchen sie Aenderungen, ist die Invariante gebrochen - das ist der
Lackmustest); die reinen `vfs-*`/`berechne-*` in `vf_standard.lsp` (via Lackmustest); die reinen `vfs-*`/`berechne-*` in `vf_standard.lsp` (via
doc/variofoerderer.md
+20 -7
View File
@@ -387,7 +387,7 @@ arbeiten auf bereits in der Zeichnung vorhandener Geometrie statt auf freier
Klick-Eingabe — fuer eine GUI eher Import/Solver-Werkzeuge als klassische Klick-Eingabe — fuer eine GUI eher Import/Solver-Werkzeuge als klassische
Formulare. Formulare.
### Modus 2 — Pfad + Zielhoehe (Solver) ### Modus 2 — aus 3D Linie MIT Zielhoehe (Solver)
| Feld | Steuerelement | Werte | | Feld | Steuerelement | Werte |
|---|---|---| |---|---|---|
@@ -400,15 +400,28 @@ Formulare.
| -> Vario-Kurve-Variante | Dropdown | Aussen / Innen | | -> Vario-Kurve-Variante | Dropdown | Aussen / Innen |
| GF-Verteilung | Dropdown | alles am Einlauf (GF1) / 1/2 GF1 + 1/2 GF2 | | GF-Verteilung | Dropdown | alles am Einlauf (GF1) / 1/2 GF1 + 1/2 GF2 |
### Modus 3 — Vorwaerts-Nachbau (Legacy, wird umgebaut) ### Modus 3 — aus 3D Linie OHNE Zielhoehe (Vorwaerts-Bau)
Baut dieselbe gezeichnete Geometrie wie Modus 2, aber VORWAERTS mit
vorgegebenen Winkeln: die Endhoehe ist hier ein Ergebnis, kein Ziel. Genau
das ist sein Anwendungsfall — wenn es keine feste Zielhoehe gibt.
| Feld | Steuerelement | Werte | | Feld | Steuerelement | Werte |
|---|---|---| |---|---|---|
| Startpunkt (3D) | Punktwahl | KS_EIN AUS-Element / Kettenanfang | | Startpunkt (3D) + Starthoehe | Punktwahl + Zahl | Kettenanfang |
| Gefaellewinkel | Zahl (Grad) | wird auch aus 2 gewaehlten 3D-Punkten vorgeschlagen | | AS-Element bauen? | Ja/Nein | bei Nein beginnt die Kette direkt am Startpunkt |
| AUS-Element Seite | Dropdown | links / rechts | | -> AS Winkel + Seite | Dropdown | 30/90 Grad · links/rechts (ein Dialog zusammen mit "bauen?") |
| Separator vor EIN? | Dropdown | Ja/Nein | | ES-Element bauen? | Ja/Nein | **vor** dem Bau gefragt, damit der ES-Fussabdruck von der letzten Geraden abgezogen werden kann |
| Einfuegen bestaetigen | Dropdown | Ja/Nein | | -> ES Winkel + Seite | Dropdown | 30/90 Grad · links/rechts |
| Pfad-Objekte | Objektauswahl | Linien + Boegen der Trasse |
| Je gerades Segment: Typ | Dropdown | GF / VF-Ab / VF-Auf / VF-Horizontal |
| -> GF-Neigung bzw. Vario-Winkel | Zahl (Grad) | kontextabhaengig |
| Je Bogen-Segment: Typ | Dropdown | GF-Bogen / Vario-Kurve (+ Variante) |
Ketten, die vor dem 2026-10-22 gebaut wurden, kennen die beiden
"bauen?"-Fragen noch nicht; sie werden beim Doppelklick automatisch erkannt
und in der alten Reihenfolge nachgebaut (siehe `alt-journal` in
`vf-linienzug-modus3`).
--- ---
lang/de_DE.json
+6 -5
View File
@@ -181,7 +181,7 @@
"vfl-soll-xyz": "\n Soll: X=%1 Y=%2 Z=%3", "vfl-soll-xyz": "\n Soll: X=%1 Y=%2 Z=%3",
"vfl-ist-xyz": "\n Ist : X=%1 Y=%2 Z=%3", "vfl-ist-xyz": "\n Ist : X=%1 Y=%2 Z=%3",
"vfl-abweichung-xyz": "\n Abweichung: dX=%1 dY=%2 dZ=%3 mm", "vfl-abweichung-xyz": "\n Abweichung: dX=%1 dY=%2 dZ=%3 mm",
"vfl-m3-titel": "\n VF-LINIENZUG - Modus 2: Pfad + Ziel-Hoehe (fertig; Anker + Solver + Bau)", "vfl-m3-titel": "\n VF-LINIENZUG - Modus 2: aus 3D Linie MIT Zielhoehe (Anker + Solver + Bau)",
"vfl-m3-alert-gf-modul": "Gefaellestrecke-Modul nicht geladen!", "vfl-m3-alert-gf-modul": "Gefaellestrecke-Modul nicht geladen!",
"vfl-m3-pfad-waehlen": "\n\nPfad-Objekte waehlen (Linien/Boegen):", "vfl-m3-pfad-waehlen": "\n\nPfad-Objekte waehlen (Linien/Boegen):",
"vfl-m3-keine-objekte": "\nKeine Objekte gewaehlt - Abbruch.", "vfl-m3-keine-objekte": "\nKeine Objekte gewaehlt - Abbruch.",
@@ -258,6 +258,7 @@
"vfl-m3-gf2-ausgleich": "\n GF2 (gemessener Ausgleich): L=%1 mm", "vfl-m3-gf2-ausgleich": "\n GF2 (gemessener Ausgleich): L=%1 mm",
"vfl-m3-kurve-back-uebersprungen": "\n >>> [M3a] Vario-Kurve im Back-Lauf - uebersprungen.", "vfl-m3-kurve-back-uebersprungen": "\n >>> [M3a] Vario-Kurve im Back-Lauf - uebersprungen.",
"vfl-m3-nichts-gebaut": "\nNichts gebaut - Abbruch.", "vfl-m3-nichts-gebaut": "\nNichts gebaut - Abbruch.",
"vfl-m3-alt-journal": "\n Hinweis: Diese Kette stammt aus der Zeit vor den Fragen AS bauen / ES bauen - sie wird in der alten Reihenfolge nachgebaut.",
"vfl-m3-fertig-header": "\n>>> VF-Linienzug (Modus 2) gebaut! <<<", "vfl-m3-fertig-header": "\n>>> VF-Linienzug (Modus 2) gebaut! <<<",
"vfl-m3-ziel-soll": "\n Ziel (Soll): X=%1 Y=%2 Z=%3", "vfl-m3-ziel-soll": "\n Ziel (Soll): X=%1 Y=%2 Z=%3",
"vfl-m3-es-ist": "\n ES (Ist): X=%1 Y=%2 Z=%3", "vfl-m3-es-ist": "\n ES (Ist): X=%1 Y=%2 Z=%3",
@@ -941,13 +942,13 @@
"vfc-warnung-untermodule-nicht-geladen": "\n[vf_core] WARNUNG: DXFM_LISP nicht gesetzt - Untermodule konnten nicht geladen werden!", "vfc-warnung-untermodule-nicht-geladen": "\n[vf_core] WARNUNG: DXFM_LISP nicht gesetzt - Untermodule konnten nicht geladen werden!",
"vfc-linienzug-modus-header": "\n\nLinienzug-Modus waehlen:", "vfc-linienzug-modus-header": "\n\nLinienzug-Modus waehlen:",
"vfc-linienzug-modus-1": "\n 1 - Manuelle Eingabe (Punkte klicken)", "vfc-linienzug-modus-1": "\n 1 - Manuelle Eingabe (Punkte klicken)",
"vfc-linienzug-modus-2": "\n 2 - 3D-Objekte + Ziel-Hoehe (Randwert-Solver, fertig)", "vfc-linienzug-modus-2": "\n 2 - aus 3D Linie MIT Zielhoehe (Hoehen werden gerechnet)",
"vfc-linienzug-modus-3": "\n 3 - 3D-Objekte stueckweise (Vorwaerts-Nachbau, in Arbeit)", "vfc-linienzug-modus-3": "\n 3 - aus 3D Linie OHNE Zielhoehe (Vorwaerts-Bau mit vorgegebenen Winkeln)",
"prompt-wahl-1-3": "\nIhre Wahl (1/2/3) [1]: ", "prompt-wahl-1-3": "\nIhre Wahl (1/2/3) [1]: ",
"vfl-qc-uform-nicht-implementiert": "\nFEHLER: 'QC Linie mit GF und U-Form' ist noch nicht implementiert - bitte Option 4 oder einen anderen Modus waehlen.", "vfl-qc-uform-nicht-implementiert": "\nFEHLER: 'QC Linie mit GF und U-Form' ist noch nicht implementiert - bitte Option 4 oder einen anderen Modus waehlen.",
"vfc-typ-standard-beschreibung": "Standard VarioFoerderer (AS/ES 90 Grad, horizontal versetzt)", "vfc-typ-standard-beschreibung": "Standard VarioFoerderer (AS/ES 90 Grad, horizontal versetzt)",
"vfc-typ-etage-beschreibung": "Etage VarioFoerderer (AS/ES 30 Grad, direkt uebereinander)", "vfc-typ-etage-beschreibung": "Etage VarioFoerderer (AS/ES 30 Grad, direkt uebereinander)",
"vfc-typ-linienzug-beschreibung": "Streckengruppe (gemischte GF/VF-Kette; Modus 1 manuell / Modus 2 Ziel-Hoehe fertig / Modus 3 stueckweise in Arbeit)", "vfc-typ-linienzug-beschreibung": "Streckengruppe (gemischte GF/VF-Kette; Modus 1 manuell / Modus 2 aus 3D Linie mit Zielhoehe / Modus 3 aus 3D Linie ohne Zielhoehe)",
"vfs-schritt6-horizontal": "\n\n6/11: Horizontale Zwischenstrecke (0 Grad, L=%1 mm)", "vfs-schritt6-horizontal": "\n\n6/11: Horizontale Zwischenstrecke (0 Grad, L=%1 mm)",
"vfs-schritt6-steigung": "\n\n6/11: Steigungsstrecke (%1 Grad, L=%2 mm)", "vfs-schritt6-steigung": "\n\n6/11: Steigungsstrecke (%1 Grad, L=%2 mm)",
"vfs-schritt6-gefaelle": "\n\n6/11: Gefaellestrecke (%1 Grad, L=%2 mm)", "vfs-schritt6-gefaelle": "\n\n6/11: Gefaellestrecke (%1 Grad, L=%2 mm)",
@@ -976,7 +977,7 @@
"vfe-step14": "\n\n14/15: Separator (300mm, cur-hz=%1)", "vfe-step14": "\n\n14/15: Separator (300mm, cur-hz=%1)",
"vfe-step15": "\n\n15/15: %1 (Ende, verkettet cur-hz=%2)", "vfe-step15": "\n\n15/15: %1 (Ende, verkettet cur-hz=%2)",
"vfe-eingefuegt": "\n>>> Etage-VarioFoerderer eingefuegt! <<<", "vfe-eingefuegt": "\n>>> Etage-VarioFoerderer eingefuegt! <<<",
"vfl-vwnb-titel": "\n VF-LINIENZUG - Modus 3: 3D-Objekte stueckweise (Vorwaerts-Nachbau, in Arbeit)", "vfl-vwnb-titel": "\n VF-LINIENZUG - Modus 3: aus 3D Linie OHNE Zielhoehe (Vorwaerts-Bau)",
"vfl-vwnb-aus-seite-menu": "\n\nAUS-Element - Seite waehlen:\n 1 - Links\n 2 - Rechts", "vfl-vwnb-aus-seite-menu": "\n\nAUS-Element - Seite waehlen:\n 1 - Links\n 2 - Rechts",
"vfl-vwnb-alert-eckwinkel": "Kein passender Bogen: Eck-Winkel %1 Grad ist nicht ~30/60/90.\nBitte die Winkel der Linien anpassen.", "vfl-vwnb-alert-eckwinkel": "Kein passender Bogen: Eck-Winkel %1 Grad ist nicht ~30/60/90.\nBitte die Winkel der Linien anpassen.",
"vfl-vwnb-alert-keine-gerade": "Pfad enthaelt keine Gerade - eine Kette muss mit einer Geraden beginnen.", "vfl-vwnb-alert-keine-gerade": "Pfad enthaelt keine Gerade - eine Kette muss mit einer Geraden beginnen.",
lang/en_GB.json
+6 -5
View File
@@ -181,7 +181,7 @@
"vfl-soll-xyz": "\n Target: X=%1 Y=%2 Z=%3", "vfl-soll-xyz": "\n Target: X=%1 Y=%2 Z=%3",
"vfl-ist-xyz": "\n Actual: X=%1 Y=%2 Z=%3", "vfl-ist-xyz": "\n Actual: X=%1 Y=%2 Z=%3",
"vfl-abweichung-xyz": "\n Deviation: dX=%1 dY=%2 dZ=%3 mm", "vfl-abweichung-xyz": "\n Deviation: dX=%1 dY=%2 dZ=%3 mm",
"vfl-m3-titel": "\n VF LINE PATH - Mode 2: path + target height (finished; anchors + solver + build)", "vfl-m3-titel": "\n VF LINE PATH - Mode 2: from 3D line WITH target height (anchors + solver + build)",
"vfl-m3-alert-gf-modul": "Gefaellestrecke module not loaded!", "vfl-m3-alert-gf-modul": "Gefaellestrecke module not loaded!",
"vfl-m3-pfad-waehlen": "\n\nSelect path objects (lines/arcs):", "vfl-m3-pfad-waehlen": "\n\nSelect path objects (lines/arcs):",
"vfl-m3-keine-objekte": "\nNo objects selected - aborting.", "vfl-m3-keine-objekte": "\nNo objects selected - aborting.",
@@ -258,6 +258,7 @@
"vfl-m3-gf2-ausgleich": "\n GF2 (measured compensation): L=%1 mm", "vfl-m3-gf2-ausgleich": "\n GF2 (measured compensation): L=%1 mm",
"vfl-m3-kurve-back-uebersprungen": "\n >>> [M3a] Vario curve in back run - skipped.", "vfl-m3-kurve-back-uebersprungen": "\n >>> [M3a] Vario curve in back run - skipped.",
"vfl-m3-nichts-gebaut": "\nNothing built - aborting.", "vfl-m3-nichts-gebaut": "\nNothing built - aborting.",
"vfl-m3-alt-journal": "\n Note: this chain predates the build AS / build ES questions - it is rebuilt in the old order.",
"vfl-m3-fertig-header": "\n>>> VF line path (mode 2) built! <<<", "vfl-m3-fertig-header": "\n>>> VF line path (mode 2) built! <<<",
"vfl-m3-ziel-soll": "\n Target (nominal): X=%1 Y=%2 Z=%3", "vfl-m3-ziel-soll": "\n Target (nominal): X=%1 Y=%2 Z=%3",
"vfl-m3-es-ist": "\n ES (actual): X=%1 Y=%2 Z=%3", "vfl-m3-es-ist": "\n ES (actual): X=%1 Y=%2 Z=%3",
@@ -941,13 +942,13 @@
"vfc-warnung-untermodule-nicht-geladen": "\n[vf_core] WARNING: DXFM_LISP not set - submodules could not be loaded!", "vfc-warnung-untermodule-nicht-geladen": "\n[vf_core] WARNING: DXFM_LISP not set - submodules could not be loaded!",
"vfc-linienzug-modus-header": "\n\nSelect line-path mode:", "vfc-linienzug-modus-header": "\n\nSelect line-path mode:",
"vfc-linienzug-modus-1": "\n 1 - Manual entry (click points)", "vfc-linienzug-modus-1": "\n 1 - Manual entry (click points)",
"vfc-linienzug-modus-2": "\n 2 - 3D objects + target height (boundary-value solver, finished)", "vfc-linienzug-modus-2": "\n 2 - from 3D line WITH target height (heights are calculated)",
"vfc-linienzug-modus-3": "\n 3 - 3D objects step by step (forward reconstruction, work in progress)", "vfc-linienzug-modus-3": "\n 3 - from 3D line WITHOUT target height (forward build with given angles)",
"prompt-wahl-1-3": "\nYour choice (1/2/3) [1]: ", "prompt-wahl-1-3": "\nYour choice (1/2/3) [1]: ",
"vfl-qc-uform-nicht-implementiert": "\nERROR: 'QC line with GF and U-shape' is not yet implemented - please choose option 4 or a different mode.", "vfl-qc-uform-nicht-implementiert": "\nERROR: 'QC line with GF and U-shape' is not yet implemented - please choose option 4 or a different mode.",
"vfc-typ-standard-beschreibung": "Standard VarioFoerderer (AS/ES 90 degrees, offset horizontally)", "vfc-typ-standard-beschreibung": "Standard VarioFoerderer (AS/ES 90 degrees, offset horizontally)",
"vfc-typ-etage-beschreibung": "Etage VarioFoerderer (AS/ES 30 degrees, directly stacked)", "vfc-typ-etage-beschreibung": "Etage VarioFoerderer (AS/ES 30 degrees, directly stacked)",
"vfc-typ-linienzug-beschreibung": "Route group (mixed GF/VF chain; mode 1 manual / mode 2 target height finished / mode 3 step by step work in progress)", "vfc-typ-linienzug-beschreibung": "Route group (mixed GF/VF chain; mode 1 manual / mode 2 from 3D line with target height / mode 3 from 3D line without target height)",
"vfs-schritt6-horizontal": "\n\n6/11: Horizontal intermediate section (0 deg, L=%1 mm)", "vfs-schritt6-horizontal": "\n\n6/11: Horizontal intermediate section (0 deg, L=%1 mm)",
"vfs-schritt6-steigung": "\n\n6/11: Incline section (%1 deg, L=%2 mm)", "vfs-schritt6-steigung": "\n\n6/11: Incline section (%1 deg, L=%2 mm)",
"vfs-schritt6-gefaelle": "\n\n6/11: Slope section (%1 deg, L=%2 mm)", "vfs-schritt6-gefaelle": "\n\n6/11: Slope section (%1 deg, L=%2 mm)",
@@ -976,7 +977,7 @@
"vfe-step14": "\n\n14/15: Separator (300mm, cur-hz=%1)", "vfe-step14": "\n\n14/15: Separator (300mm, cur-hz=%1)",
"vfe-step15": "\n\n15/15: %1 (end, chained cur-hz=%2)", "vfe-step15": "\n\n15/15: %1 (end, chained cur-hz=%2)",
"vfe-eingefuegt": "\n>>> Etage VarioFoerderer inserted! <<<", "vfe-eingefuegt": "\n>>> Etage VarioFoerderer inserted! <<<",
"vfl-vwnb-titel": "\n VF LINE PATH - Mode 3: 3D objects step by step (forward reconstruction, work in progress)", "vfl-vwnb-titel": "\n VF LINE PATH - Mode 3: from 3D line WITHOUT target height (forward build)",
"vfl-vwnb-aus-seite-menu": "\n\nOUT element - select side:\n 1 - Left\n 2 - Right", "vfl-vwnb-aus-seite-menu": "\n\nOUT element - select side:\n 1 - Left\n 2 - Right",
"vfl-vwnb-alert-eckwinkel": "No matching arc: corner angle %1 deg is not ~30/60/90.\nPlease adjust the angles of the lines.", "vfl-vwnb-alert-eckwinkel": "No matching arc: corner angle %1 deg is not ~30/60/90.\nPlease adjust the angles of the lines.",
"vfl-vwnb-alert-keine-gerade": "Path contains no straight - a chain must begin with a straight.", "vfl-vwnb-alert-keine-gerade": "Path contains no straight - a chain must begin with a straight.",
menu/SSG_LIB.mnu
+1 -1
View File
@@ -27,7 +27,7 @@
[->Streckengruppe] [->Streckengruppe]
[Werte manuell]^C^C(ssg-ensure "VarioFoerderer") LinienzugVarioFoerdererManuell [Werte manuell]^C^C(ssg-ensure "VarioFoerderer") LinienzugVarioFoerdererManuell
[aus 3D Linie mit Zielhoehe]^C^C(ssg-ensure "VarioFoerderer") LinienzugVarioFoerdererZielhoehe [aus 3D Linie mit Zielhoehe]^C^C(ssg-ensure "VarioFoerderer") LinienzugVarioFoerdererZielhoehe
[<-3D Objekte stueckweise (in Arbeit)]^C^C(ssg-ensure "VarioFoerderer") LinienzugVarioFoerdererStueckweise [<-aus 3D Linie ohne Zielhoehe]^C^C(ssg-ensure "VarioFoerderer") LinienzugVarioFoerdererStueckweise
[Vario_Kette_Merge]^C^C(ssg-ensure "VarioFoerderer") Vario_Kette_Merge [Vario_Kette_Merge]^C^C(ssg-ensure "VarioFoerderer") Vario_Kette_Merge
[<-VarioFoerderer nachruesten (Marker)]^C^C(ssg-ensure "VarioFoerderer") VARIOFOERDERER_NACHRUESTEN [<-VarioFoerderer nachruesten (Marker)]^C^C(ssg-ensure "VarioFoerderer") VARIOFOERDERER_NACHRUESTEN
[->Gefaellestrecke] [->Gefaellestrecke]