[FIX] Scanner-Insert in TEST_MUBEA: eff wurde durch AND statt IF zu T

mubea:build-separator-one nutzte (and blockname (ssg-ils-block-laden
blockname)) fuer eff - AutoLISPs AND liefert bei mehreren wahren
Ausdruecken T zurueck statt des letzten Werts (anders als in Common
Lisp/Scheme). Sobald ein Blockname (z.B. "Scanner") direkt gefunden
wurde, statt ueber den Separator_SP-Fallback zu laufen, wurde eff=T
an "_.INSERT" uebergeben. Fix: (if blockname (ssg-ils-block-laden
blockname)).

Ausserdem: Scanner-Testeintrag in mubea.json ergaenzt und
_vario_count/_separator_count in test_mubea.py, damit erwartete
Ergebniszahlen auch bei "anzahl">1 (Template->mehrere Kopien) stimmen.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>

tests/test_mubea.lsp

@@ -5,7 +5,9 @@
 ;;   - Kreisel   (Eintraege mit "id",   Block KREISEL_*)   via kreisel-insert-script
 ;;   - Vario     (test_id "VF_*")        Block VF_*         via variofoerderer-einfuegen
 ;;                                                          + vf-block-erstellen
-;;                (deltaL/L_VF werden fuer winkel+deltaH geloest, L_GF Split 500/4230)
+;;                (deltaL/L_VF werden fuer winkel+deltaH geloest, L_GF Split 500/4230;
+;;                 "anzahl"/"delta_y"/"delta_x" wie bei Gefaelle: Template->mehrere
+;;                 Foerderer mit fortlaufend suffixiertem test_id, _01.._anzahl)
 ;;   - Gefaelle  (test_id "GF_*", Modus 1) Block GF_*       via gefaellestrecke-einfuegen
 ;;   - Separator (Eintraege mit "block")  Block S-LP/Separator_SP via _.INSERT
 ;;
@@ -109,18 +111,9 @@
 ;; erzwingen in test_foerderer.lsp), statt den automatisch kleinsten
 ;; gueltigen Winkel zu nehmen. L_GF1 aus JSON ist der Vorlauf-Zielwert;
 ;; L_GF2 (Nachlauf) ist der Rest (L_GF_gesamt - L_GF1).
-(defun mubea:build-vario (e / tid richtung deltaH deltaL winkel-soll gf1-ziel seite hz
+(defun mubea:build-vario-one (tid richtung deltaL deltaH winkel-soll gf1-ziel seite hz
-                            startpunkt ergebnis winkel-treffer best-winkel L_GF L_VF
+                               startpunkt / ergebnis winkel-treffer best-winkel L_GF L_VF
-                            gf1 gf2 hoehe-bis lastEnt ent)
+                               gf1 gf2 hoehe-bis lastEnt ent)
-  (setq tid        (ssg-val e "test_id")
-        richtung   (ssg-val e "richtung")
-        deltaL     (float (ssg-val e "deltaL"))
-        deltaH     (float (ssg-val e "deltaH"))
-        winkel-soll(ssg-val e "winkel")
-        gf1-ziel   (float (ssg-val e "L_GF1"))
-        seite      (ssg-val e "seite")
-        hz         (ssg-val e "hz")
-        startpunkt (list (float (ssg-val e "x")) (float (ssg-val e "y")) (float (ssg-val e "z"))))
   (if (or (null seite) (= seite "")) (setq seite "links"))
   (if (null hz) (setq hz 0.0) (setq hz (float hz)))
   (princ (strcat "\n  [VARIO] " tid " -> deltaL=" (rtos deltaL 2 0)
@@ -172,6 +165,48 @@
       (mubea:result-json tid "vario" "failed" nil nil nil nil)))
 )
 
+;; --- Vario(s) aus einem Template-Eintrag bauen ---
+;; Wie mubea:build-gf: "anzahl" identische Kopien, je um "delta_y"/"delta_x" (mm)
+;; versetzt (nur startpunkt x/y - Default 1/0/0 -> genau ein Foerderer wie bisher).
+;; Bei mehreren Kopien wird "test_id" fortlaufend suffixiert (_01.._anzahl),
+;; bei genau einer Kopie bleibt der Template-Name erhalten (kompatibel zur
+;; frueheren Einzelbenennung).
+;; Rueckgabe: LISTE von Ergebnis-JSON-Strings (eine je Kopie).
+(defun mubea:build-vario (e / tid0 richtung deltaL deltaH winkel-soll gf1-ziel seite hz
+                            start0 anzahl dy dx i off nr tid startpunkt ergebnisse)
+  (setq tid0       (ssg-val e "test_id")
+        richtung   (ssg-val e "richtung")
+        deltaL     (float (ssg-val e "deltaL"))
+        deltaH     (float (ssg-val e "deltaH"))
+        winkel-soll(ssg-val e "winkel")
+        gf1-ziel   (float (ssg-val e "L_GF1"))
+        seite      (ssg-val e "seite")
+        hz         (ssg-val e "hz")
+        start0     (list (float (ssg-val e "x")) (float (ssg-val e "y")) (float (ssg-val e "z")))
+        anzahl     (ssg-val e "anzahl")
+        dy         (ssg-val e "delta_y")
+        dx         (ssg-val e "delta_x"))
+  (if (or (null anzahl) (< anzahl 1)) (setq anzahl 1))
+  (setq dy (if dy (float dy) 0.0))
+  (setq dx (if dx (float dx) 0.0))
+
+  (setq ergebnisse '() i 0)
+  (while (< i anzahl)
+    (setq off (float i))
+    (setq nr  (1+ i))
+    (setq tid
+      (if (> anzahl 1)
+        (strcat tid0 "_" (if (< nr 10) (strcat "0" (itoa nr)) (itoa nr)))
+        tid0))
+    (setq startpunkt (list (+ (car start0) (* dx off)) (+ (cadr start0) (* dy off)) (caddr start0)))
+    (setq ergebnisse
+      (cons (mubea:build-vario-one tid richtung deltaL deltaH winkel-soll gf1-ziel seite hz startpunkt)
+            ergebnisse))
+    (setq i (1+ i))
+  )
+  (reverse ergebnisse)
+)
+
 
 ;; --- Gefaellestrecke: Init-Konflikt umgehen -----------------------------
 ;; gefaellestrecke-einfuegen ruft "(if (not *lib-initialized*) (gf-init-
@@ -281,26 +316,33 @@
 )
 
 
-;; --- Separator (Eintraege mit "block"): _.INSERT der Blockdatei ---
+;; --- Ein einzelner Separator: Blockdefinition laden, dann per Name einfuegen ---
 ;; Verwendet den in JSON genannten Block; faellt auf Separator_SP zurueck
 ;; (Block der "Separator einfuegen"-Routine ILS_SEPARATOR_INSERT).
-(defun mubea:build-separator (e idx / blockname x y z rot pt pfad tid)
+;; Nutzt ssg-ils-block-laden (wie Kreisel/GF/VF), um den Block vorab zu
-  (setq blockname (ssg-val e "block")
+;; definieren, dann klassisches "_.INSERT eff pt "" "" rot" (wie ueberall sonst
-        x   (float (ssg-val e "x"))
+;; im Projekt, z.B. omni:insert-dxf/KreiselInsert). NEUE Bloecke (z.B. "Scanner")
-        y   (float (ssg-val e "y"))
+;; koennen dabei eine zusaetzliche Rueckfrage einschieben, die die feste
-        z   (float (ssg-val e "z"))
+;; Antwortfolge verschiebt und das INSERT nicht sauber beendet (CMDACTIVE bleibt
-        rot (ssg-val e "rotation"))
+;; > 0) - dieselbe Absicherung wie in ssg-ils-block-laden-dim (Zeilen 418f.) und
-  (if (null rot) (setq rot 0))
+;; omni:insert-dxf (Zeile 980): nach dem INSERT verbleibende Prompts mit Leer-
-  (setq rot (float rot))
+;; Antworten (Enter) abfangen, bis der Befehl sauber beendet ist.
-  (setq pt (list x y z))
+(defun mubea:build-separator-one (tid blockname pt rot / eff)
-  (setq tid (strcat "SEPARATOR_" (itoa idx)))
   (princ (strcat "\n  [SEP] " tid " '" (if blockname blockname "?")
-                 "' -> (" (rtos x 2 0) "," (rtos y 2 0) "," (rtos z 2 0) ") R=" (rtos rot 2 0)))
+                 "' -> (" (rtos (car pt) 2 0) "," (rtos (cadr pt) 2 0) "," (rtos (caddr pt) 2 0)
-  (setq pfad (and blockname (ssg-ils-block-datei blockname)))
+                 ") R=" (rtos rot 2 0)))
-  (if (null pfad) (setq pfad (ssg-ils-block-datei "Separator_SP")))
+  ;; NICHT (and blockname (ssg-ils-block-laden blockname)) verwenden: AutoLISPs
-  (if pfad
+  ;; AND liefert bei mehreren wahren Ausdruecken T zurueck, NICHT den letzten
+  ;; Wert (anders als z.B. in Common Lisp/Scheme) - eff waere dann bei einem
+  ;; erfolgreich direkt gefundenen Block (z.B. "Scanner", das NICHT ueber den
+  ;; Separator_SP-Fallback laeuft) das Symbol T statt des Blocknamen-Strings,
+  ;; und das anschliessende "_.INSERT" wuerde einen Block namens T einfuegen.
+  (setq eff (if blockname (ssg-ils-block-laden blockname)))
+  (if (null eff) (setq eff (ssg-ils-block-laden "Separator_SP")))
+  (if eff
     (progn
-      (command "_.INSERT" pfad pt "" "" rot)
+      (command "_.INSERT" eff pt "" "" rot)
+      (while (> (getvar "CMDACTIVE") 0) (command ""))
       (mubea:ent-json tid "separator" (entlast)))
     (progn
       ;; Kein Block gefunden -> sichtbaren Platzhalter zeichnen
@@ -312,6 +354,47 @@
                         (if blockname blockname "S-LP") nil pt nil)))
 )
 
+;; --- Separator(en) aus einem Eintrag bauen (Eintraege mit "block") ---
+;; Wie mubea:build-gf: "anzahl" identische Kopien, je um "delta_y"/"delta_x"
+;; (mm) versetzt (Default 1/0/0 -> genau ein Separator am angegebenen Ort).
+;; Namensbasis fuer die Kopien: "test_id", falls angegeben (erzeugt
+;; "<test_id>_01".."<test_id>_anzahl"), sonst Fallback "SEPARATOR_<idx>" wie
+;; bisher (Einzel-Separatoren ohne "test_id" bleiben dadurch unveraendert).
+;; "assigned_to" bleibt reine Dokumentation und wird hier NICHT zur Namens-
+;; bildung verwendet, da mehrere Separatoren denselben assigned_to-Wert teilen
+;; koennen (z.B. mehrere S-LP-Eintraege mit assigned_to "GF_Mubea_01").
+;; Rueckgabe: LISTE von Ergebnis-JSON-Strings (eine je Kopie).
+(defun mubea:build-separator (e idx / blockname x0 y0 z rot tid0 anzahl dy dx
+                               i nr tid pt ergebnisse)
+  (setq blockname (ssg-val e "block")
+        x0  (float (ssg-val e "x"))
+        y0  (float (ssg-val e "y"))
+        z   (float (ssg-val e "z"))
+        rot (ssg-val e "rotation")
+        tid0   (cond ((ssg-val e "test_id")) ((strcat "SEPARATOR_" (itoa idx))))
+        anzahl (ssg-val e "anzahl")
+        dy     (ssg-val e "delta_y")
+        dx     (ssg-val e "delta_x"))
+  (if (null rot) (setq rot 0))
+  (setq rot (float rot))
+  (if (or (null anzahl) (< anzahl 1)) (setq anzahl 1))
+  (setq dy (if dy (float dy) 0.0))
+  (setq dx (if dx (float dx) 0.0))
+
+  (setq ergebnisse '() i 0)
+  (while (< i anzahl)
+    (setq nr  (1+ i))
+    (setq tid
+      (if (> anzahl 1)
+        (strcat tid0 "_" (if (< nr 10) (strcat "0" (itoa nr)) (itoa nr)))
+        tid0))
+    (setq pt (list (+ x0 (* dx (float i))) (+ y0 (* dy (float i))) z))
+    (setq ergebnisse (cons (mubea:build-separator-one tid blockname pt rot) ergebnisse))
+    (setq i (1+ i))
+  )
+  (reverse ergebnisse)
+)
+
 
 ;; --- JSON-Export der Mubea-Ergebnisse ---
 (defun mubea:export-results (tests-out-dir / out-json f first)

tests/test_mubea.py

@@ -33,18 +33,30 @@ def _is_gefaelle(item):
     return tid.startswith("GF_")
 
 
+def _vario_count(testdata):
+    """Wie _gefaelle_count: ein VF-Eintrag ist ein Template, das ueber 'anzahl'
+    expandiert wird (Default 1, falls Feld fehlt)."""
+    return sum(int(t.get("anzahl", 1)) for t in testdata if _is_vario(t))
+
+
 def _gefaelle_count(testdata):
     """Anzahl erzeugter Gefaellestrecken: ein GF-Eintrag ist ein Template, das
     ueber 'anzahl' expandiert wird (Default 1, falls Feld fehlt)."""
     return sum(int(t.get("anzahl", 1)) for t in testdata if _is_gefaelle(t))
 
 
+def _separator_count(testdata):
+    """Wie _gefaelle_count: ein Separator-Eintrag kann per 'anzahl' mehrere
+    identische, versetzte Kopien erzeugen (Default 1, falls Feld fehlt)."""
+    return sum(int(t.get("anzahl", 1)) for t in testdata if _is_separator(t))
+
+
 def _expected_counts(testdata):
     return {
         "kreisel":        sum(1 for t in testdata if _is_kreisel(t)),
-        "vario":          sum(1 for t in testdata if _is_vario(t)),
+        "vario":          _vario_count(testdata),
         "gefaellestrecke": _gefaelle_count(testdata),
-        "separator":      sum(1 for t in testdata if _is_separator(t)),
+        "separator":      _separator_count(testdata),
     }
 
 

tests/testdata/mubea.json

@@ -47,6 +47,16 @@
     "rotation": 90,
     "assigned_to": "Kreisel_links"
   },
+  {
+    "comment": "Scanner linken Kreisel unten",
+    "function": "insert",
+    "block": "Scanner",
+    "x": 400,
+    "y": -4823,
+    "z": 1467,
+    "rotation": 0,
+    "assigned_to": "Kreisel_links"
+  },
   {
     "id": "Kreisel_rechts",
     "function": "insert",