[ADD] Kreiseldrehrichtungsanzeige hinzugefügt; [CHANGE] Insert des Kreisel mit Ausrichtung wird jetzt über die vom Benutzer gezeichnete Eingabelinie erreichnet; [FIX] Fehlende config Datei für die Positionierung der Stückliste hinzugefügt

2026-10-16 11:41:51 +02:00
1 parent b6aa3d604c
commit 6b8f0f9ec3
@@ -105,7 +105,7 @@ Detaillierte Dokumentation aller Funktionen und Befehle: siehe `Lisp/README.md`.
 | `ssg_blocktools.lsp` | SSG_BLOCK_COUNT, SSG_BLOCK_DELETE, SSG_ATTR_ERSETZEN | Block-Werkzeuge fuer das aktuelle Layout (Ursprung ACADSST `TOOLS.LSP`/`ssg.lsp`): Einfuegungen zaehlen (Pick, wcmatch-Muster oder Statistik aller Bloecke), alle Einfuegungen loeschen (Rueckfrage, gesperrte Layer bleiben), Attributwerte zeichnungsweit/in Auswahl suchen+ersetzen (Vorschau mit Anzahl, Teilstring oder Gesamtwert). Wirksamer Blockname (dynamische Bloecke). Reine Kerne `ssg-bt-name-passt-p`, `ssg-bt-zaehle-namen`, `ssg-bt-wert-neu` in `tests/test_unit.lsp` getestet |
 | `ssg_texttools.lsp` | SSG_TEXT_ERSETZEN, SSG_TEXT_PARALLEL, SSG_TEXT_HOEHE, SSG_TEXT_STIL | Text-Werkzeuge (Ursprung ACADSST `CHGTEXT`/`PARTEXT`/`ALTHOEHE`/`ALTSTIL`): Suchen/Ersetzen in TEXT, MTEXT und Block-Attributen (nutzt `ssg-bt-*`, daher NACH `ssg_blocktools` laden), Text parallel zu Linie/Polylinie/Bogen (lesbar ausgerichtet, Abstand), Hoehe/Stil aendern. Arbeitet in der XY-Ebene des Welt-KS. Reine Kerne `ssg-tt-lesbarer-winkel`, `ssg-tt-versetzt` getestet |
 | `ssg_stueckliste.lsp` | SSG_FAEHNCHEN_STUECKLISTE | Positions-Faehnchen + Stuecklistentabelle, komplett AUS DER ZEICHNUNG - es wird keine Datei eingelesen. Der Benutzer waehlt die Elemente aus (`ssg-sl-erkannte-elemente`: `ssget`-Auswahl, Enter ohne Auswahl = alle erkannten im aktuellen Layout; der reine Filter `ssg-sl-elemente-aus-ss` laesst nicht erkannte Objekte still wegfallen, man darf also grosszuegig ein Fenster aufziehen). `ssg-sl-klasse` klassifiziert Blocknamen (`KREISEL_*`/`ECKRAD_*` -> "ILS Kreisel/Eckrad", `VF_*`/`GF_*` -> "ILS Streckengruppe", `GR_*` -> "Rohrgeruest", `AP60*`/`AP110*`/`AP_110*`/`APG110*` -> je eigene Omniflo-Geraden-Gruppe; wirksamer Blockname ueber `ssg-bt-effname`, also auch dynamische Bloecke). Jedes einzelne Element bekommt ein Faehnchen (`ssg-sl-faehnchen`, Rechteck/Kreis/Automation-Rahmen + Text) an der unteren linken Ecke seiner Bounding-Box (aus `csv:get-bbox` - liefert Zentrum+Abmessungen, NICHT Eckpunkte, die Ecke wird im Code daraus berechnet); die Tabelle (`ssg-sl-tabelle-zeichnen`) gruppiert GROB je Elementklasse (keine Sivas-Artikelaufloesung wie `export_sivas.py`) zu einer Zeile mit Anzahl + Laengensumme aus dem `LAENGE`-Attribut (`ssg-sl-gruppieren`/reiner Kern `ssg-sl-gruppieren-werte`), mehrere gleichartige Elemente tragen daher dieselbe Positionsnummer. **Bewusst KEIN Datei-Import wie bei Walz/Bihler**: dort vergab ein externes System die Positionsnummern und lieferte sie als Datei zurueck, die das CAD nur abzeichnete - bei Walz (`MENU/POSITION.LSP`) eine `.pos`/`.zei` aus einem Clipper-Warenwirtschaftssystem mit Koordinaten-Zuordnung, bei Bihler ITB (`Walz_und_Bihler/SBCADBib/ITB-Module_ori.lsp`, `c:bea_pos`) eine `.pos` mit Zuordnung ueber den Entity-Handle. Diese Umwege sind hier nicht nachgebaut (Entscheidung 2026-10): Nummern und Mengen entstehen in dieser Funktion, die Stuecklisten-AUSGABE liefern EXPORTSIVAS/EXPORTCSV aus denselben Block-Attributen. Der alte `c:stueckl` (Laengen-Summierung ueber hartcodierte Walz-Profillayer wie `L-2`=ST, `A-7`=AP110) hat ebenfalls kein Aequivalent im dxfmakros-Datenmodell (Block-Attribute statt Linien-Layer). Braucht `csv:get-bbox`/`csv:get-attrib` aus `export.lsp` und `ssg-bt-effname` aus `ssg_blocktools.lsp` - muss daher NACH beiden geladen werden (siehe `ssg-ensure`-Reihenfolge in `SSG_LIB.mnl`/`ssg_load.lsp`). Reine Kerne `ssg-sl-klasse`, `ssg-sl-gruppieren-werte` in `tests/test_unit.lsp` getestet |
-| `KreiselInsert.lsp` | KreiselInsert, KreiselConnect, KreiselRedraw, KreiselQuick, KreiselEdit, KreiselParams, KreiselLabelSetup, KreiselLabelPos, KreiselLabelHoehe, ILS_Eckrad, EckradEdit, KREISEL_WEICHEN | ILS Kreisel und Eckrad komplett in AutoLISP. **Beruehrpunkte/Weichen** (`kreisel-bp-*`, Befehl KREISEL_WEICHEN, Menue Kreisel-Module -> Weichenpunkte ermitteln): ermittelt aus den Blockparametern (Einfuegepunkt, Drehung, ABSTAND - nicht aus der Geometrie, Modell wie `draw-module`) die Beruehrpunkte aller `KREISEL_*`/`ECKRAD_*` GLEICHER Hoehe (`toleranz_hoehe`): Rad/Rad (`Kreis/Kreis`) und Rad/Laufprofil (`Kreis/Tangente`), nur auf der freien Radseite (aeusserer Halbkreis inkl. Flanken; Eckrad ganz frei), Toleranz `toleranz_beruehrung` (component_defaults.json, Sektion kreisel). Kapsel-Mindestabstand < 2r - tol = KOLLISION (Ueberschneidung), Kreisel Seite an Seite (Beruehrung nur an Flanke/Profil) = KOLLISION `Tangente/Tangente` - beide werden gemeldet, aber nie zur Weiche. Ausgabe: Konsolenliste + Kreis-Marker (Layer `kreisel_weiche`/`kreisel_kollision` aus layer.cfg, XDATA `SSG_KR_WEICHE`, jeder Lauf ersetzt die alten). Der Export schreibt dieselben Punkte als `kreisel_weichen.json` neben `export_raw.json` (`csv:kreisel-weichen-schreiben`, export.lsp); `export_csv.py` uebernimmt sie (`export_neighbors.load_lisp_kreisel_weichen`/`lisp_touch_switches`, Rueckfall auf `compute_kreisel_touch_switches` nur ohne Datei), `export_sivas.py` setzt daraus Merkmal 4403 "Anzahl Weichen ILS". Reine Kerne `kreisel-bp-element`/`-paar`/`-berechnen` in `tests/test_unit.lsp` (`tu-tests-kreisel-bp`, u.a. mit den 11 Einfuegungen aus `tests/testdata/schnittspunkte_kreisel.dxf` -> 10 Beruehrungen) getestet. Eckrad: eigener Dialog `eckrad_edit.dcl` (`eckrad-dialog`, reiner Kern `eckrad-dialog-werte` getestet) beim Einfuegen (ILS_Eckrad, ohne GUI Konsolen-Rueckfall) und per Doppelklick (EckradEdit); kein Abstand/Typ, Drehung als freier Winkel statt fester Kreisel-Ausrichtung. `ils-eckrad-insert` behaelt eine vorhandene NUMMER (Edit -> gleicher Blockname `ECKRAD_n`). Kreiselname: `draw-module` setzt `Bezeichnung` nur noch bei leerem Wert auf die Vorgabe `KreiselN` (eigener Name aus KreiselEdit bleibt erhalten); Beschriftung `kreisel-label-text` = `KREISEL n: <Name> <TYP>_<ABSTAND>` (ohne Namen bzw. bei Vorgabename wie bisher `KREISEL n: <TYP>_<ABSTAND>`); da die Beschriftung als TEXT in der wiederverwendeten Blockdefinition `KREISEL_n_TYP_ABSTAND` steckt, setzt `kreisel-label-aktualisieren` sie dort per `entmod` neu (wirkt auf alle Referenzen der Definition) |
+| `KreiselInsert.lsp` | KreiselInsert, KreiselConnect, KreiselRedraw, KreiselQuick, KreiselEdit, KreiselParams, KreiselLabelSetup, KreiselLabelPos, KreiselLabelHoehe, ILS_Eckrad, EckradEdit, KREISEL_WEICHEN | ILS Kreisel und Eckrad komplett in AutoLISP. **Drehrichtungspfeil**: `draw-module` fuegt `data/ils/Drehrichtungspfeil.dwg` auf AN8-Mitte (Block-KS 90 Grad, da die DWG fuer Kreisel Nord->Sued gezeichnet ist; cfg `kreisel.pfeil_winkel`) und SP8-Mitte (+180) mit in den KREISEL_n-Block ein, GUZ = X-Skalierung -1 (reiner Kern `kreisel-pfeil-params`, getestet); Eckrad: ein Pfeil auf der Radmitte mit dem AN8-Winkel (`eckrad-pfeil-params`); bei wiederverwendeter Blockdefinition (KREISEL_n bzw. ECKRAD_n) zieht `kreisel-pfeil-aktualisieren` die Spiegelung per `entmod` nach. **Beruehrpunkte/Weichen** (`kreisel-bp-*`, Befehl KREISEL_WEICHEN, Menue Kreisel-Module -> Weichenpunkte ermitteln): ermittelt aus den Blockparametern (Einfuegepunkt, Drehung, ABSTAND - nicht aus der Geometrie, Modell wie `draw-module`) die Beruehrpunkte aller `KREISEL_*`/`ECKRAD_*` GLEICHER Hoehe (`toleranz_hoehe`): Rad/Rad (`Kreis/Kreis`) und Rad/Laufprofil (`Kreis/Tangente`), nur auf der freien Radseite (aeusserer Halbkreis inkl. Flanken; Eckrad ganz frei), Toleranz `toleranz_beruehrung` (component_defaults.json, Sektion kreisel). Kapsel-Mindestabstand < 2r - tol = KOLLISION (Ueberschneidung), Kreisel Seite an Seite (Beruehrung nur an Flanke/Profil) = KOLLISION `Tangente/Tangente` - beide werden gemeldet, aber nie zur Weiche. Ausgabe: Konsolenliste + Kreis-Marker (Layer `kreisel_weiche`/`kreisel_kollision` aus layer.cfg, XDATA `SSG_KR_WEICHE`, jeder Lauf ersetzt die alten). Der Export schreibt dieselben Punkte als `kreisel_weichen.json` neben `export_raw.json` (`csv:kreisel-weichen-schreiben`, export.lsp); `export_csv.py` uebernimmt sie (`export_neighbors.load_lisp_kreisel_weichen`/`lisp_touch_switches`, Rueckfall auf `compute_kreisel_touch_switches` nur ohne Datei), `export_sivas.py` setzt daraus Merkmal 4403 "Anzahl Weichen ILS". Reine Kerne `kreisel-bp-element`/`-paar`/`-berechnen` in `tests/test_unit.lsp` (`tu-tests-kreisel-bp`, u.a. mit den 11 Einfuegungen aus `tests/testdata/schnittspunkte_kreisel.dxf` -> 10 Beruehrungen) getestet. Eckrad: eigener Dialog `eckrad_edit.dcl` (`eckrad-dialog`, reiner Kern `eckrad-dialog-werte` getestet) beim Einfuegen (ILS_Eckrad, ohne GUI Konsolen-Rueckfall) und per Doppelklick (EckradEdit); kein Abstand/Typ, Drehung als freier Winkel statt fester Kreisel-Ausrichtung. `ils-eckrad-insert` behaelt eine vorhandene NUMMER (Edit -> gleicher Blockname `ECKRAD_n`). Kreiselname: `draw-module` setzt `Bezeichnung` nur noch bei leerem Wert auf die Vorgabe `KreiselN` (eigener Name aus KreiselEdit bleibt erhalten); Beschriftung `kreisel-label-text` = `KREISEL n: <Name> <TYP>_<ABSTAND>` (ohne Namen bzw. bei Vorgabename wie bisher `KREISEL n: <TYP>_<ABSTAND>`); da die Beschriftung als TEXT in der wiederverwendeten Blockdefinition `KREISEL_n_TYP_ABSTAND` steckt, setzt `kreisel-label-aktualisieren` sie dort per `entmod` neu (wirkt auf alle Referenzen der Definition) |
 | `VarioFoerderer.lsp` (Wrapper fuer `vf_core.lsp`/`vf_standard.lsp`/`vf_etage.lsp`/`vf_linienzug.lsp`) | FOERDERANLAGE, VARIOFOERDERER_EDIT, VARIOFOERDERER_NACHRUESTEN, Vario_Kette_Merge, VF_SEKTION_RESTORE, VF_WIZARD_AN, VF_WIZARD_AUS | Vario-Foerderanlagen Generator (Typen Standard/Etage/Linienzug); Standard- UND Etage-Typ: Werteingabe per DCL-Dialog, inkl. der vorgelagerten Eingabemodus-Wahl 3D-Linie/Werte manuell (`vfc_eingabemodus`, `vfc-dialog-eingabemodus-waehlen`) - beide Modi laufen seitdem in denselben Basis-/Winkel-Dialog, der Konsolen-Pfad ist nur noch Rueckfall bei abgeschalteter GUI/anderer Sprache. Der Dialog-Ablauf ist zentral in vf_core (`vf-dialog-ablauf`/`vf-dialog-berechnen-einfuegen`, parametrisiert ueber Typ-Registry `*vf-typ-registry*` + Flag `horizontal-p`); `vfs-standard-dialog-ablauf`/`vfe-etage-dialog-ablauf` sind nur noch duenne Wrapper darauf. Beide nutzen dieselben Dialoge `vfs-dialog-eingabe-basis`/`vfs-dialog-winkel-verteilung` und den gemeinsamen L_GF/L_VF-Solve `vf-winkel-solve` (vf_core; berechne-alle-winkel/berechne-winkel-etage teilen ihn); Doppelklick auf VF_n-Block ruft VARIOFOERDERER_EDIT, das per SSG_VF_EDIT-XDATA-Marker ("standard"/"etage"/"linienzug") in den passenden Neuaufbau-Zweig dispatcht (`vfe-edit-ent` fuer Etage, `vfl-edit-ent` fuer Linienzug); Altbestand-Bloecke ohne Marker werden abgewiesen. Linienzug (Modus 1, `vf-linienzug-modus`) zeichnet jede interaktive Eingabe in einem Journal auf (`vfl-in-point`/`-string`/`-real`/`-int`) und schreibt es als XDATA auf den fertigen `VF_n`-Block; ein Abbruch (ESC) loescht dadurch nichts mehr, sondern wickelt die bis dahin gebaute Teil-Geometrie ebenso zu einem Block (`vfl-modus-abbruch-sichern`) - sie bleibt stehen und ist sofort per Doppelklick weiter editierbar/fortsetzbar. Der komplette Linienzug-Hauptstrang (Menue-Fragen von AS-Element bis Kettenende, inkl. GF-Bogen/Vario-Kurve/VF-Einheit-Fortsetzung) laeuft per Default ueber DCL-Dialoge statt Konsole (`*vfl-wizard-mode*`, Befehle VF_WIZARD_AN/VF_WIZARD_AUS): `vfl-in-string`/`-int`/`-real` zeigen bei aktivem Wizard-Modus generische Dialoge aus `dcl/vf_linienzug_wizard.dcl` (Zahl-Eingabe bzw. Mehrfachauswahl aus `vfl-menu`/`vfl-menu-int`) statt `getstring`/`getint`/`getreal` aufzurufen; die ORIGINALEN Konsolen-Fragen (princ + get*, de/en ueber ssg-text) bleiben unveraendert im Code (Fallback bei Fehlern via `vl-catch-all-apply`, siehe `doc/variofoerderer.md`). `vfl-edit-ent` liest das Journal, zeigt die Sektionen ueber einen DCL-Dialog (`vfl-dlg-position`, `dcl/vfl_edit.dcl`) an, kuerzt bei Bedarf auf eine gewaehlte Sektion (stummer Replay der behaltenen Eingaben, umgeht den Wizard-Zweig komplett) und baut danach interaktiv weiter. Linienzug Modus 2 (Pfad+Zielhoehe-Solver, `vf-linienzug-modus2`) nutzt dieselben Wrapper PLUS die neue Objektauswahl-Wrapper-Funktion `vfl-in-selection` (Pfad-Objekte als stabile Entity-Handles journalisiert, neue Journal-Art `"OBJS"`) und schreibt sein Journal unter dem eigenen XDATA-Marker `"linienzug2"`; Doppelklick baut hier NICHT abschnittsweise, sondern per vollem Reset 1:1 aus dem Journal neu auf (`vfl-edit-ent2`, dispatcht aus `vfl-edit-ent` per Marker) - Modus 3 (Vorwaerts-Nachbau) bleibt bewusst reine Konsole (im Code selbst als Legacy/"wird umgebaut" markiert). `Vario_Kette_Merge` (in vf_linienzug.lsp) fuehrt mehrere einzeln gebaute VF_n-Bloecke ab einem gewaehlten Start-Baustein ueber die reale KS_AUS->KS_EIN-Nachbarschaft zu einem Gesamt-Block zusammen (aggregierte Attribute, Luecken-Erkennung). Die interaktiven Editier-Pfade (`vfl-edit-ent` Sektions-Zweig, `vfl-edit-ent2`) rufen den Neuaufbau BEWUSST direkt auf, NICHT ueber `vl-catch-all-apply`: der alte Block ist beim Neuaufbau schon per `entdel` weg, und ein Catch faengt den Abbruch VOR `*error*` ab - der Abbruch-Wickler `vfl-modus-abbruch-sichern` kaeme nie zum Zug und die ganze Kette bliebe als lose Einzelteile ohne Block liegen (Fehlerbild "VF-Block aufgebrochen"). Nur der nicht-interaktive Batch-Konverter `vfl-konvertiere-ent` behaelt den Catch (die Batch-Schleife muss weiterlaufen) und meldet den betroffenen Block. Die Abbruch-Handler setzen zusaetzlich `*ssg-ils-dim*` zurueck, weil der Aufrufer, der das sonst tut, nach einem Abbruch nicht mehr erreicht wird. Recovery-Pfad fuer bereits aufgebrochene Ketten: `VF_SEKTION_RESTORE` (vf_linienzug.lsp) setzt das Ketten-Journal aus der XDATA der losen Objekte zusammen - `SSG_VF_EDIT_SEG` traegt pro Entity den Journal-Abschnitt DER ITERATION, in der es entstand (indiziert mit dem ersten Glied-Index darin; eine VF-Einheit mit eingebetteten Vario-Kurven erzeugt mehrere Glieder in einer Iteration), `SSG_VF_EDIT_PRE` auf den Entities des ersten Gliedes die Praeambel (Startpunkt/Starthoehe/AS). Die `.dbg`-Dateien sind reine AUSGABE und werden von keinem Befehl gelesen (dbgopen legt sie bei jedem Lauf neu an) - Wiederherstellungs-Daten gehoeren in die XDATA. `vf_konstanten.lsp` (von vf_core.lsp vor den drei Submodulen geladen) sLine truncated
 | `vf_spec.lsp` (von vf_core.lsp NACH vf_linienzug.lsp geladen) | VF_SPEC_BAU | Linienzug-Ketten aus **Eingabedaten** bauen, ohne Dialog und ohne Konsolenfrage (Stufe 1 aus `doc/todo/plan-vf-interactive.md`). Eine **Spec** beschreibt eine Kette in Domaenenwerten (`"links"`, `"winkel"`, `"aussen"`, ja/nein) statt in Menue-Codes; `vsp-journal` uebersetzt sie in ein Eingabe-Journal, `vsp-bau-aus-spec` spielt es per `vfl-journal-replay-start` durch den UNVERAENDERTEN `vf-linienzug-modus` (Replay-Kern `vsp-bau-journal` - nimmt auch ein unveraendert uebernommenes, aufgezeichnetes Journal, z.B. aus `dxf_anlage_export.py`). Damit traegt der fertige Block dasselbe `SSG_VF_EDIT`-Journal wie eine handgebaute Kette und bleibt per Doppelklick editier- und 2D/3D-konvertierbar - kein Journal-Konsument muss etwas von Specs wissen. Wichtige Regeln, die der Uebersetzer kennt: der Menue-Code haengt am Frame (erste Sektion 4 Optionen ohne GF-Bogen, danach 5), `hz` steht nur beim ERSTEN Segment im Journal, und `erst-hor` unterscheidet den horizontalen Erstkoerper einer VF-Einheit (Separator-/Endpunktfragen vorab) vom gewinkelten (keine Frage). Fehlerverhalten: fail fast - `vsp-pruefen` sammelt ALLE Spec-Fehler, gebaut wird dann nichts (nichts wird geraten). Ergebnis-Record je Kette mit `status` (`executed`/`warnung`/`desync`/`abbruch`/`spec-fehler`), Block/Handle/Einfuegepunkt/Attributen, `prompts` (muss 0 sein), `glieder_soll` vs. `glieder_ist` (Desync-Detektor, der auch bei aufgehender Queue greift) und den gesammelten `meldungen`. Headless-Rahmen `vsp-headless-an`/`-aus` (Save/Restore von `*vfl-headless*`, `*vfl-wizard-mode*`, `*ssg-gui-aus*` + zaehlende Eingabe-Stubs). Spec-Datei flach als JSON (`ssg-load-json` liest zeilenweise), erzeugt von `lib/vf_spec_export.py`. Gegenstueck/Referenz in Python: derselbe Emitter, gegen die 5 echten HundM-Ketten rundlaufgeprueft |
 | `Gefaellestrecke.lsp` | GEFAELLESTRECKE, GEFAELLESTRECKE_EDIT | Gefaelle-Foerderanlage (AUS -> Staustrecke skaliert -> Separator -> EIN); Modus 1 per DCL-Dialog (Einfuegehoehe, Element-Winkel 30/90); Doppelklick auf GF_n-Block ruft GEFAELLESTRECKE_EDIT (Dialog vorbelegt, Neuaufbau; die Einfuegehoehe kommt aus der aktuellen Z des Einfuegepunkts statt aus XDATA/HOEHE_VON_mm, damit ein in Z verschobener Block per OK direkt auf der neuen Hoehe neu entsteht - gleiches gilt fuer die 2D/3D-Umschaltung `gf-konvertiere-ent`; der GF-Linienzug-Rebuild nutzt weiter die absoluten Segmentpunkte aus XDATA) |
@@ -314,6 +314,77 @@
 )


+;; --- Drehrichtungspfeil (data/ils/Drehrichtungspfeil.dwg) ---
+;; Die DWG ist fuer einen Kreisel Nord -> Sued (AN oben, SP unten, also
+;; Einfuegewinkel 270) und Drehrichtung im Uhrzeigersinn gezeichnet.
+;; Im Block liegt der Kreisel entlang +X (Winkel 0); die Drehung des
+;; Kreisels kommt ueber den Einfuegewinkel des KREISEL_n-Blocks automatisch
+;; dazu. Der Pfeil wird daher im Block um 0 - 270 = 90 Grad gedreht.
+(setq *kreisel-pfeil-block*   "Drehrichtungspfeil")
+(setq *kreisel-pfeil-winkel*  (ssg-cfg-or "kreisel" "pfeil_winkel" 90.0))
+
+;; X-Skalierung des Pfeils: UZS -> 1, GUZ -> -1 (Spiegelung an der eigenen
+;; Y-Achse, die Pfeilspitze zeigt dann in die Gegenrichtung).
+(defun kreisel-pfeil-xskal (drehrichtung)
+  (if (equal drehrichtung "GUZ") -1.0 1.0)
+)
+
+;; Reiner Kern: Einfuegeparameter beider Pfeile im Block-KS des Kreisels.
+;; Rueckgabe: ((punkt winkel xskal) (punkt winkel xskal)) - AN8, dann SP8
+;; (SP8 um 180 Grad gedreht).
+(defun kreisel-pfeil-params (radius abstand drehrichtung / xs)
+  (setq xs (kreisel-pfeil-xskal drehrichtung))
+  (list (list (list radius 0.0 0.0) *kreisel-pfeil-winkel* xs)
+        (list (list (+ radius abstand) 0.0 0.0)
+              (rem (+ *kreisel-pfeil-winkel* 180.0) 360.0) xs))
+)
+
+;; Reiner Kern fuers Eckrad: ein Pfeil auf der Radmitte (Block-Ursprung),
+;; ausgerichtet wie der AN8-Pfeil eines Kreisels gleicher Drehung.
+(defun eckrad-pfeil-params (drehrichtung)
+  (list (list (list 0.0 0.0 0.0) *kreisel-pfeil-winkel*
+              (kreisel-pfeil-xskal drehrichtung)))
+)
+
+;; Einen Pfeil einfuegen. Ab dem zweiten Mal per Blockname, damit INSERT
+;; nicht nach dem Neudefinieren der bestehenden Definition fragt.
+(defun kreisel-pfeil-einfuegen (pt winkel xs)
+  (command "_.INSERT"
+           (if (tblsearch "BLOCK" *kreisel-pfeil-block*)
+             *kreisel-pfeil-block*
+             (strcat *block-path* *kreisel-pfeil-block* ".dwg"))
+           pt xs 1.0 winkel)
+)
+
+;; Alle Pfeile einer Parameterliste ((punkt winkel xskal) ...) einfuegen
+;; (beim Aufbau der Blockdefinition). Fehlt die DWG, wird ohne Pfeil gebaut.
+(defun kreisel-pfeile-einfuegen (params)
+  (if (findfile (strcat *block-path* *kreisel-pfeil-block* ".dwg"))
+    (foreach p params
+      (kreisel-pfeil-einfuegen (car p) (cadr p) (caddr p))
+    )
+    (princ (ssg-textf "kreisel-warn-pfeil-fehlt" (list *kreisel-pfeil-block*)))
+  )
+)
+
+;; Spiegelung der Pfeile in einer BESTEHENDEN Blockdefinition KREISEL_n_...
+;; nachziehen (Edit/Redraw mit geaenderter DREHRICHTUNG - der Blockname
+;; enthaelt die Drehrichtung nicht, die Definition wird wiederverwendet).
+;; Wirkt wie kreisel-label-aktualisieren auf alle Referenzen der Definition.
+(defun kreisel-pfeil-aktualisieren (bname drehrichtung / e ed xs)
+  (setq xs (kreisel-pfeil-xskal drehrichtung))
+  (setq e (tblobjname "BLOCK" bname))
+  (while (setq e (entnext e))
+    (setq ed (entget e))
+    (if (and (= (cdr (assoc 0 ed)) "INSERT")
+             (= (strcase (cdr (assoc 2 ed))) (strcase *kreisel-pfeil-block*))
+             (not (equal (cdr (assoc 41 ed)) xs 1e-9)))
+      (entmod (subst (cons 41 xs) (assoc 41 ed) ed))
+    )
+  )
+)
+
+
 ;; Attribut-Funktionen: ssg-attrib-read, ssg-attrib-merge,
 ;; ssg-attrib-defaults, ssg-attrib-make-defs aus ssg_core.lsp

@@ -439,6 +510,11 @@
      ;; SP8 Kreis (Spannstation) bei (radius+abstand, 0) - Dim-Suffix im Dateinamen
      (command "_.INSERT" (strcat *block-path* "SP8_" *ki-dxfm-dim* ".dwg") (list (+ radius abstand) 0.0 0.0) 1 1 0)

+      ;; Drehrichtungspfeile auf AN8- und SP8-Mitte (SP8 um 180 Grad gedreht,
+      ;; GUZ gespiegelt). Fehlt die DWG, wird der Kreisel ohne Pfeil gebaut.
+      (kreisel-pfeile-einfuegen
+        (kreisel-pfeil-params radius abstand (cdr (assoc "DREHRICHTUNG" attribs))))
+
      ;; Tangenten-Layer: bevorzugt aus cfg/layer.cfg (Baugruppe
      ;; "kreisel_tangente"), sonst der bisherige Hartwert S_LP.
      (if (null (ssg-layer-anlegen "kreisel_tangente" T))
@@ -506,6 +582,8 @@
      (kreisel-label-aktualisieren bname
        (kreisel-label-text kreisel-nummer (cdr (assoc "Bezeichnung" attribs))
                            (if is-pin "PIN" "STANDARD") abstand))
+      ;; ebenso die Spiegelung der Drehrichtungspfeile
+      (kreisel-pfeil-aktualisieren bname (cdr (assoc "DREHRICHTUNG" attribs)))
    )
  )

@@ -561,87 +639,89 @@
 ;; KreiselInsert: Manuell Position + Parameter
 ;; --------------------------------------------

+;; Reiner Kern: Abstand und Rotation aus Basispunkt und gezeigtem Punkt der
+;; Abstands-Abfrage (Gummiband-Linie, 2D in der XY-Ebene).
+;; Ohne Punkt (Enter) -> Vorgabe-Abstand, Rotation 0.
+;; Rueckgabe: (abstand rotation-in-grad), Rotation in [0, 360)
+(defun kreisel-insert-richtung (pt p2 vorgabe / a)
+  (if (and p2 (> (distance (list (car pt) (cadr pt)) (list (car p2) (cadr p2))) 1e-6))
+    (progn
+      (setq a (* (/ 180.0 pi) (angle (list (car pt) (cadr pt)) (list (car p2) (cadr p2)))))
+      (list (distance (list (car pt) (cadr pt)) (list (car p2) (cadr p2)))
+            (if (>= a 359.9999999) 0.0 a))
+    )
+    (list vorgabe 0.0)
+  )
+)
+
 ;; --------------------------------------------
 ;; KreiselInsert: Manuell Position + Parameter
+;; Abfrage: 1. Basispunkt (AN-Seite), 2. Abstand als Gummiband-Linie - die
+;; Richtung der Linie ist zugleich die Rotation (Wert tippen = direkte
+;; Distanzeingabe in Zeigerichtung), 3. Hoehe (Vorgabe aus angeklicktem
+;; Block bzw. Z des Basispunkts), 4. Kreiselart.
 ;; --------------------------------------------
-(defun c:KreiselInsert ( / pt abstand typ rotation rotStr hoehe 
+(defun c:KreiselInsert ( / pt p2 erg abstand typ rotation hoehe hoehe-vorgabe
                           selectedEnt blockAttribs oldOsmode)
  (ssg-start (ssg-text "kreisel-start-insert") '(("OSMODE") ("CECOLOR")))
-  
+
  ;; Temporär Osnap für Blockerkennung setzen
  (setq oldOsmode (getvar "OSMODE"))
  (setvar "OSMODE" (logior oldOsmode 512))  ;; 512 = INS (Block-Einfügepunkt)
-  
-  ;; 1. Einfuegepunkt
+
+  ;; 1. Basispunkt (AN-Seite)
  (setq pt (getpoint (ssg-text "kreisel-prompt-basispunkt")))
-  (if (null pt)
-    (progn
-      (setvar "OSMODE" oldOsmode)
-      (ssg-end)
-      (princ (ssg-text "kreisel-abbruch-befehl"))
-      (princ)
-      (return)
-    )
-  )
-  
+
  ;; Osnap zurücksetzen auf den ursprünglichen Wert
  (setvar "OSMODE" oldOsmode)
-  
-  ;; 2. Prüfen ob ein Block getroffen wurde
-  (setq selectedEnt (nentselp pt))
-  
-  ;; --- HÖHE BESTIMMEN ---
-  (cond
-    ;; Fall 1: Auf einem Kreisel-Block geklickt
-    ((and selectedEnt 
-          (setq selectedEnt (car selectedEnt))
-          (setq blockAttribs (ssg-attrib-read selectedEnt))
-          (assoc "HOEHE" blockAttribs))
-     (setq hoehe (atof (cdr (assoc "HOEHE" blockAttribs))))
-     (princ (ssg-textf "kreisel-hoehe-von-bestehendem" (list (rtos hoehe 2 0))))
-    )
-    ;; Fall 2: Punkt hat Z-Koordinate > 0
-    ((and (> (length pt) 2) (> (caddr pt) 0))
-     (setq hoehe (caddr pt))
-     (princ (ssg-textf "kreisel-hoehe-aus-3dpunkt" (list (rtos hoehe 2 0))))
-    )
-    ;; Fall 3: Sonst separat abfragen
-    (t
-     (setq hoehe (getreal (ssg-textf "kreisel-prompt-hoehe-z" (list (rtos *kreisel-default-hoehe* 2 0)))))
-     (if (null hoehe) (setq hoehe *kreisel-default-hoehe*))
+
+  (if (null pt)
+    (princ (ssg-text "kreisel-abbruch-befehl"))
+    (progn
+      ;; Hoehen-Vorgabe: angeklickter Block mit HOEHE, sonst Z des Punkts,
+      ;; sonst Default (abgefragt wird erst nach dem Abstand)
+      (setq selectedEnt (nentselp pt))
+      (setq hoehe-vorgabe
+        (cond
+          ((and selectedEnt
+                (setq selectedEnt (car selectedEnt))
+                (setq blockAttribs (ssg-attrib-read selectedEnt))
+                (assoc "HOEHE" blockAttribs))
+           (atof (cdr (assoc "HOEHE" blockAttribs))))
+          ((and (> (length pt) 2) (> (caddr pt) 0))
+           (caddr pt))
+          (t *kreisel-default-hoehe*)
+        )
+      )
+
+      ;; 2. Abstand (Tangentenlaenge) - Linie gibt auch den Winkel vor
+      (setq p2 (getpoint pt (ssg-textf "kreisel-prompt-abstand"
+                                       (list (rtos *kreisel-default-laenge* 2 0)))))
+      (setq erg (kreisel-insert-richtung pt p2 *kreisel-default-laenge*)
+            abstand  (car erg)
+            rotation (cadr erg))
+      (princ (ssg-textf "kreisel-abstand-ausgabe" (list (rtos abstand 2 0))))
+
+      ;; 3. Hoehe (Z-Koordinate)
+      (setq hoehe (getreal (ssg-textf "kreisel-prompt-hoehe-z" (list (rtos hoehe-vorgabe 2 0)))))
+      (if (null hoehe) (setq hoehe hoehe-vorgabe))
+
+      ;; 4. Kreiselart
+      (setq typ (kreisel-ask-typ))
+
+      (princ (ssg-textf "kreisel-insert-zusammenfassung"
+                         (list (rtos rotation 2 1) (rtos hoehe 2 0) typ)))
+
+      ;; Modul einfuegen
+      (draw-module (list (car pt) (cadr pt) hoehe) abstand rotation
+                   (list (cons "KREISELART" typ)
+                         (cons "HOEHE" (rtos hoehe 2 0))))
+
+      (princ (ssg-text "kreisel-insert-fertig"))
    )
  )
-
-  ;; 3. Abstand
-  (initget 6)
-  (setq abstand (getdist (list (car pt) (cadr pt))
-                         (ssg-textf "kreisel-prompt-abstand" (list (rtos *kreisel-default-laenge* 2 0)))))
-  (if (null abstand) (setq abstand *kreisel-default-laenge*))
-  (princ (ssg-textf "kreisel-abstand-ausgabe" (list (rtos abstand 2 0))))
-
-  ;; 4. Rotation
-  (setq rotStr (getstring (ssg-text "kreisel-prompt-rotation")))
-  (if (= rotStr "")
-    (setq rotation 0.0)
-    (setq rotation (atof rotStr))
-  )
-
-  ;; 5. Kreiselart
-  (setq typ (kreisel-ask-typ))
-
-  (princ (ssg-textf "kreisel-insert-zusammenfassung"
-                     (list (rtos rotation 2 1) (rtos hoehe 2 0) typ)))
-
-  ;; 6. Modul einfuegen
-  (draw-module (list (car pt) (cadr pt) hoehe) abstand rotation
-               (list (cons "KREISELART" typ)
-                     (cons "HOEHE" (rtos hoehe 2 0))))
-
-  ;; KEIN weiteres (setvar "OSMODE" ...) mehr nötig!
-  ;; ssg-end stellt nur CLAYER und CMDECHO wieder her, nicht OSMODE
-  
-  (princ (ssg-text "kreisel-insert-fertig"))
  (ssg-end)
+  (princ)
 )


@@ -1429,6 +1509,9 @@
      (dbgp (strcat "INSERT Block: " *block-path* "AN8_" *ki-dxfm-dim* ".dwg"))
      (command "_.INSERT" (strcat *block-path* "AN8_" *ki-dxfm-dim* ".dwg") (list 0.0 0.0 0.0) 1 1 0)

+      ;; Drehrichtungspfeil auf die Radmitte (GUZ gespiegelt)
+      (kreisel-pfeile-einfuegen (eckrad-pfeil-params (cdr (assoc "DREHRICHTUNG" attribs))))
+
      ;; Unsichtbare Attribut-Definitionen erzeugen
      (dbgp (strcat "Erzeuge " (itoa (length *eckrad-attrib-defs*)) " Attribut-Definitionen"))
      (ssg-attrib-make-defs *eckrad-attrib-defs* 50.0)
@@ -1461,6 +1544,8 @@
    (progn
      (princ (ssg-textf "kreisel-bestehende-blockdef" (list bname)))
      (dbgp (strcat "Verwende bestehende Blockdefinition: " bname))
+      ;; EckradEdit behaelt ECKRAD_n - Spiegelung des Pfeils nachziehen
+      (kreisel-pfeil-aktualisieren bname (cdr (assoc "DREHRICHTUNG" attribs)))
    )
  )

@@ -675,7 +675,7 @@ AutoLISP-Implementierung fuer ILS Kreisel und Eckrad. Enthaelt alle Befehle fuer

 | Befehl | Beschreibung |
 | --- | --- |
-| `c:KreiselInsert` | Kreisel-Block an Punkt einfuegen (mit Dialog fuer Parameter) |
+| `c:KreiselInsert` | Kreisel-Block einfuegen: Basispunkt (AN-Seite), Abstand als Gummiband-Linie (deren Richtung = Rotation), Hoehe, Kreiselart |
 | `c:KreiselConnect` | Zwei Punkte waehlen, Kreisel dazwischen einfuegen |
 | `c:KreiselRedraw` | Bestehenden Kreisel mit neuen Parametern neu zeichnen |
 | `c:KreiselQuick` | Schnelleinfuegung mit Standardwerten |
@@ -0,0 +1,29 @@
+{
+    "_kommentar": "Konfiguration fuer SSG_FAEHNCHEN_STUECKLISTE (Lisp/ssg_stueckliste.lsp). Vorgaben fuer den Startdialog, Darstellung von Fuehrung und Tabelle (Walz-Layout, siehe tests/testdata/positionierung_nach_walz.dxf) und Regeln je Bauteiltyp.",
+    "startnummer": 100,
+    "alle_positionen_in_fahne": false,
+    "pos_layer": {
+        "modus": "suffix",
+        "suffix": "-POS",
+        "fest": "POS"
+    },
+    "tabellen_layer": "D-1-POS",
+    "fuehrung": {
+        "textstil": "Pos",
+        "font": "arial.ttf",
+        "texthoehe": 75,
+        "landung": [105, 159],
+        "landing_gap": 15,
+        "rahmen": true
+    },
+    "tabelle": {
+        "textstil": "Standard",
+        "texthoehe": 100,
+        "spalten": [300, 500, 500, 900, 4866],
+        "zeilenhoehe": 136
+    },
+    "regeln": [
+        { "block": "GR_Traeger_*", "marker": "mitte" },
+        { "block": "GR_Fahrstrecke_*", "marker": "mitte" }
+    ]
+}
@@ -284,7 +284,6 @@
    "kreisel-hoehe-aus-3dpunkt": "\n-> Hoehe aus 3D-Punkt uebernommen: %1",
    "kreisel-hoehe-aus-basispunkt": "\n-> Höhe aus Basispunkt übernommen: %1",
    "kreisel-hoehe-aus-startpunkt": "\n-> Hoehe aus Startpunkt uebernommen: %1",
-    "kreisel-hoehe-von-bestehendem": "\n-> Höhe von bestehendem Kreisel übernommen: %1",
    "kreisel-insert-zusammenfassung": "\n-> Rotation: %1  Höhe: %2  Kreiselart: %3",
    "kreisel-labelsetup-fertig": "\nNeue Einstellungen: Höhe=%1, Farbe=%2, Y-Versatz=%3, Schriftart=Arial",
    "kreisel-neue-beschriftungsposition": "\nNeue Beschriftungsposition: X=%1 Y=%2",
@@ -471,7 +470,6 @@
    "kreisel-prompt-basispunkt": "\nBasispunkt (AN-Seite): ",
    "kreisel-prompt-block-auswaehlen": "\nKreisel-Block auswaehlen: ",
    "kreisel-prompt-endpunkt": "\nEndpunkt (SP-Seite aussen): ",
-    "kreisel-prompt-rotation": "\nRotation in Grad <0>: ",
    "kreisel-prompt-startpunkt": "\nStartpunkt (AN-Seite aussen): ",
    "kreisel-quick-fertig": "\nSchnell Einfuegen fertig.",
    "kreisel-start-connect": "Kreisel Smart Connect",
@@ -490,6 +488,7 @@
    "kreisel-typ-opt-pin": "\n[2] PIN",
    "kreisel-typ-opt-standard": "\n[1] STANDARD (ohne PIN)",
    "kreisel-warn-blockpfad": "\n[KreiselInsert] WARNUNG: Block-Pfad nicht ermittelbar!",
+    "kreisel-warn-pfeil-fehlt": "\n[KreiselInsert] WARNUNG: %1.dwg nicht gefunden - Kreisel ohne Drehrichtungspfeil.",
    "kreisel-warn-core-fehlt": "\n[KreiselInsert] WARNUNG: ssg_core.lsp nicht gefunden - Standardwerte.",
    "omni-abbruch": "\nAbgebrochen.",
    "omni-abbruch-bogen": "\n[BOGEN] Abgebrochen.",
@@ -284,7 +284,6 @@
    "kreisel-hoehe-aus-3dpunkt": "\n-> Height taken from 3D point: %1",
    "kreisel-hoehe-aus-basispunkt": "\n-> Height taken from base point: %1",
    "kreisel-hoehe-aus-startpunkt": "\n-> Height taken from start point: %1",
-    "kreisel-hoehe-von-bestehendem": "\n-> Height taken from existing Kreisel: %1",
    "kreisel-insert-zusammenfassung": "\n-> Rotation: %1  Height: %2  Kreisel type: %3",
    "kreisel-labelsetup-fertig": "\nNew settings: Height=%1, Colour=%2, Y offset=%3, Font=Arial",
    "kreisel-neue-beschriftungsposition": "\nNew label position: X=%1 Y=%2",
@@ -471,7 +470,6 @@
    "kreisel-prompt-basispunkt": "\nBase point (AN side): ",
    "kreisel-prompt-block-auswaehlen": "\nSelect Kreisel block: ",
    "kreisel-prompt-endpunkt": "\nEnd point (SP side, outer): ",
-    "kreisel-prompt-rotation": "\nRotation in degrees <0>: ",
    "kreisel-prompt-startpunkt": "\nStart point (AN side, outer): ",
    "kreisel-quick-fertig": "\nQuick insert done.",
    "kreisel-start-connect": "Kreisel Smart Connect",
@@ -490,6 +488,7 @@
    "kreisel-typ-opt-pin": "\n[2] PIN",
    "kreisel-typ-opt-standard": "\n[1] STANDARD (without PIN)",
    "kreisel-warn-blockpfad": "\n[KreiselInsert] WARNING: block path not determinable!",
+    "kreisel-warn-pfeil-fehlt": "\n[KreiselInsert] WARNING: %1.dwg not found - carousel without direction arrow.",
    "kreisel-warn-core-fehlt": "\n[KreiselInsert] WARNING: ssg_core.lsp not found - using defaults.",
    "omni-abbruch": "\nCancelled.",
    "omni-abbruch-bogen": "\n[ARC] Cancelled.",
@@ -803,6 +803,27 @@
 (defun tu-tests-kreisel ( / _e)
  (princ "\n[KreiselInsert]")

+  ;; Drehrichtungspfeil: AN8-Mitte 90 Grad, SP8-Mitte 270 Grad, GUZ gespiegelt
+  (tu-eqf "kreisel-pfeil-params/uzs"
+    '(((400.0 0.0 0.0) 90.0 1.0) ((2700.0 0.0 0.0) 270.0 1.0))
+    (kreisel-pfeil-params 400.0 2300.0 "UZS"))
+  (tu-eqf "kreisel-pfeil-params/guz"
+    '(((400.0 0.0 0.0) 90.0 -1.0) ((2700.0 0.0 0.0) 270.0 -1.0))
+    (kreisel-pfeil-params 400.0 2300.0 "GUZ"))
+  (tu-eqf "kreisel-pfeil-xskal/nil-ist-uzs" 1.0 (kreisel-pfeil-xskal nil))
+  (tu-eqf "eckrad-pfeil-params/guz"
+    '(((0.0 0.0 0.0) 90.0 -1.0)) (eckrad-pfeil-params "GUZ"))
+
+  ;; KreiselInsert: Abstand + Rotation aus der Gummiband-Linie
+  (tu-eqf "kreisel-insert-richtung/ost"
+    '(2300.0 0.0) (kreisel-insert-richtung '(100.0 100.0 0.0) '(2400.0 100.0 0.0) 2300.0))
+  (tu-eqf "kreisel-insert-richtung/sued"
+    '(1500.0 270.0) (kreisel-insert-richtung '(0.0 0.0 0.0) '(0.0 -1500.0 0.0) 2300.0))
+  (tu-eqf "kreisel-insert-richtung/z-ignoriert"
+    '(1000.0 90.0) (kreisel-insert-richtung '(0.0 0.0 2000.0) '(0.0 1000.0 0.0) 2300.0))
+  (tu-eqf "kreisel-insert-richtung/enter-vorgabe"
+    '(2300.0 0.0) (kreisel-insert-richtung '(0.0 0.0 0.0) nil 2300.0))
+
  ;; Projektion eines Punktes auf eine Gerade
  (tu-eqf "kreisel-project-point/lot"
    '(0.0 0.0) (kreisel-project-point '(0.0 5.0) '(0.0 0.0) '(10.0 0.0)))