325 lines
15 KiB
GDScript
325 lines
15 KiB
GDScript
extends SceneTree
|
||
## Editor-Tests (headless): Karte t_3a998ae4 — Objekt-Bibliothek, Snap-to-Ground,
|
||
## Raster-Snap, svmap-Roundtrip mit Objekten.
|
||
## Ausführen: godot --headless --path . --script res://tests/test_library.gd
|
||
## Exit 0 = alles grün. Läuft OHNE UI (LibraryBrowser/ObjectOps/SvmapIO/SvmapDocument).
|
||
## UI-Funktionen (Gruppen-Aufklappen, Thumbnail-Anzeige) werden im Desktop-Smoke
|
||
## verifiziert (--library-demo), nicht hier.
|
||
|
||
var failures := 0
|
||
var checks := 0
|
||
|
||
|
||
func _init() -> void:
|
||
_run_tests()
|
||
if failures == 0:
|
||
print("ALL OK: %d checks" % checks)
|
||
quit(0)
|
||
else:
|
||
print("FAILED: %d/%d checks" % [failures, checks])
|
||
quit(1)
|
||
|
||
|
||
func _check(cond: bool, label: String) -> void:
|
||
checks += 1
|
||
if cond:
|
||
print(" ok: %s" % label)
|
||
else:
|
||
failures += 1
|
||
print(" FAIL: %s" % label)
|
||
|
||
|
||
func _run_tests() -> void:
|
||
_test_manifest_load()
|
||
_test_groups()
|
||
_test_thumbnails()
|
||
_test_grid_snap()
|
||
_test_snap_to_ground()
|
||
_test_snap_to_ground_undo()
|
||
_test_crud_undo_all_objects()
|
||
_test_svmap_roundtrip_objects()
|
||
|
||
|
||
# ------------------------------------------------------- Bibliothek laden ----
|
||
|
||
func _load_manifest() -> Dictionary:
|
||
var parsed: Variant = JSON.parse_string(FileAccess.get_file_as_string(SvmapIO.MANIFEST_PATH))
|
||
return parsed if parsed is Dictionary else {}
|
||
|
||
|
||
func _test_manifest_load() -> void:
|
||
print("Testgruppe: Bibliothek laden (library/objects.json)")
|
||
var manifest := _load_manifest()
|
||
_check(not manifest.is_empty(), "Manifest lädt und ist ein Objekt")
|
||
var lib: Dictionary = manifest.get("objects", {})
|
||
_check(lib.size() == 54, "Katalog hat die 54 Objekte (15 Basis + 39 Natur-Update, ist %d)" % lib.size())
|
||
var all_ok := true
|
||
for oid in lib.keys():
|
||
var entry: Dictionary = lib[oid]
|
||
if int(entry.get("poly", 0)) <= 0:
|
||
all_ok = false
|
||
var col: Dictionary = entry.get("collision", {})
|
||
if str(col.get("shape", "")).is_empty():
|
||
all_ok = false
|
||
_check(all_ok, "jedes Objekt hat poly > 0 + Kollider-Eintrag")
|
||
# Anzeigenamen decken ALLE IDs ab — feste Übersetzung (NAMES) ODER der
|
||
# automatische Fallback (ID großschreiben). Neue Pipeline-Objekte brauchen
|
||
# daher KEINEN Editor-Quellcode-Touch mehr.
|
||
var names_ok := lib.keys().all(func(oid) -> bool:
|
||
return not LibraryBrowser.object_label(str(oid)).is_empty())
|
||
_check(names_ok, "deutsche Namen für alle IDs vorhanden")
|
||
_check(LibraryBrowser.object_label("crate_wood") == "Holzkiste", "object_label: crate_wood → Holzkiste")
|
||
_check(LibraryBrowser.object_label("gibts_nicht") == "Gibts Nicht", "object_label: unbekannte ID fällt auf capitalize zurück")
|
||
|
||
|
||
func _test_groups() -> void:
|
||
print("Testgruppe: Gruppen (Gruppe/Einzelobjekt im Browser)")
|
||
var manifest := _load_manifest()
|
||
var lib: Dictionary = manifest.get("objects", {})
|
||
var groups := LibraryBrowser.groups_in_order(manifest)
|
||
var seen := {}
|
||
var all_in := true
|
||
for group in groups:
|
||
_check(not str(group["label"]).is_empty(), "Gruppe „%s“ hat Label" % str(group["key"]))
|
||
for oid in (group["ids"] as Array):
|
||
if seen.has(oid):
|
||
all_in = false
|
||
seen[oid] = true
|
||
_check(all_in, "keine ID in zwei Gruppen")
|
||
_check(seen.size() == lib.size(), "alle %d IDs landen in einer Gruppe (ist %d)" % [lib.size(), seen.size()])
|
||
_check(LibraryBrowser.group_of("tree_pine") == "bäume", "group_of: tree_pine → bäume (Natur-Update hat 'natur' aufgelöst)")
|
||
_check(LibraryBrowser.group_of("crate_wood") == "kisten", "group_of: crate_wood → kisten")
|
||
_check(LibraryBrowser.group_of("baum_kiefer_1") == "bäume", "group_of: baum_kiefer_1 → bäume")
|
||
_check(LibraryBrowser.group_of("fels_moos_platte") == "felsen", "group_of: fels_moos_platte → felsen")
|
||
_check(LibraryBrowser.group_of("gras_kurz") == "gras", "group_of: gras_kurz → gras")
|
||
_check(LibraryBrowser.group_of("pilz_morchel") == "pilze", "group_of: pilz_morchel → pilze")
|
||
_check(LibraryBrowser.group_of("fremdes_ding") == "sonstiges", "group_of: unbekannte ID → sonstiges")
|
||
var vorhanden := {}
|
||
for oid in lib.keys():
|
||
vorhanden[str(oid)] = true
|
||
var gruppen_komplett := true
|
||
for key in LibraryBrowser.GROUP_IDS:
|
||
if key == "sonstiges":
|
||
continue
|
||
for oid in (LibraryBrowser.GROUP_IDS[key] as Array):
|
||
if not vorhanden.has(str(oid)):
|
||
gruppen_komplett = false
|
||
_check(gruppen_komplett, "jede feste Gruppe listet nur IDs, die es im Katalog gibt")
|
||
# Gruppen, die im Katalog leer sind, werden nicht angezeigt (außer Sonstiges).
|
||
var labels: Array = []
|
||
for group in groups:
|
||
labels.append(str(group["label"]))
|
||
var no_empty := true
|
||
for group in groups:
|
||
if str(group["key"]) != "sonstiges" and (group["ids"] as Array).is_empty():
|
||
no_empty = false
|
||
_check(no_empty, "leere feste Gruppen tauchen nicht auf")
|
||
|
||
|
||
func _test_thumbnails() -> void:
|
||
print("Testgruppe: Thumbnails (128 px, einmalig gerendert + committed)")
|
||
var manifest := _load_manifest()
|
||
var lib: Dictionary = manifest.get("objects", {})
|
||
var missing: Array = []
|
||
var wrong_size := false
|
||
for oid in lib.keys():
|
||
var path := LibraryBrowser.thumb_path(str(oid))
|
||
if not FileAccess.file_exists(path):
|
||
missing.append(str(oid))
|
||
continue
|
||
var img := Image.load_from_file(path)
|
||
if img == null or img.get_width() != 128 or img.get_height() != 128:
|
||
wrong_size = true
|
||
_check(missing.is_empty(), "Thumbnail für jedes Objekt vorhanden (fehlend: %s)" % str(missing))
|
||
_check(not wrong_size, "alle Thumbnails sind 128×128")
|
||
var tex := LibraryBrowser.load_thumb("crate_wood", 40)
|
||
_check(tex != null, "load_thumb liefert Textur")
|
||
var fallback := LibraryBrowser.load_thumb("gibts_nicht")
|
||
_check(fallback == null, "load_thumb: fehlendes Thumbnail → null (Button fällt aufs Text-Layout zurück)")
|
||
|
||
|
||
# ------------------------------------------------------------ Raster-Snap ----
|
||
|
||
func _test_grid_snap() -> void:
|
||
print("Testgruppe: Raster-Snap (1 m)")
|
||
_check(ObjectOps.snap_coord(10.4, true) == 10.0, "10.4 rastet auf 10")
|
||
_check(ObjectOps.snap_coord(10.6, true) == 11.0, "10.6 rastet auf 11")
|
||
_check(ObjectOps.snap_coord(-0.6, true) == -1.0, "-0.6 rastet auf -1")
|
||
_check(ObjectOps.snap_coord(-0.4, true) == 0.0, "-0.4 rastet auf 0")
|
||
_check(ObjectOps.snap_coord(10.4, false) == 10.4, "aus = unverändert")
|
||
_check(ObjectOps.snap_coord(10.4, true, 4.0) == 12.0, "4-m-Raster: 10.4 → 12")
|
||
|
||
|
||
# ---------------------------------------------------------- Snap to Ground ---
|
||
|
||
## Alle Heightmap-Samples auf einen 16-bit-Wert setzen → Terrain überall
|
||
## gleich hoch (h = min + v/65535 × Spannweite). Für Snap-Tests ohne
|
||
## Terrain-Werkzeug. uint16 little-endian (Low-Byte zuerst, map_format.md).
|
||
func _flatten_terrain(doc: Dictionary, v: int) -> void:
|
||
var terrain: Dictionary = doc["terrain"]
|
||
var res := int(terrain["resolution"])
|
||
var bytes := PackedByteArray()
|
||
bytes.resize(res * res * 2)
|
||
for i in res * res:
|
||
bytes[i * 2] = v & 0xFF
|
||
bytes[i * 2 + 1] = (v >> 8) & 0xFF
|
||
terrain["heightmap_r16_b64"] = Marshalls.raw_to_base64(bytes)
|
||
|
||
|
||
func _test_snap_to_ground() -> void:
|
||
print("Testgruppe: Snap to Ground (alle schwebenden Objekte auf Terrain-Höhe)")
|
||
var doc := SvmapDocument.create_new("Snap-Test", 1024.0, "mittag")
|
||
(doc["objects"] as Array).append({"id": "crate_wood", "pos": [10.0, 0.0, 10.0], "scale": 1.0, "rot_y_deg": 0.0})
|
||
(doc["objects"] as Array).append({"id": "tree_pine", "pos": [-5.0, 0.0, 3.0], "scale": 1.0, "rot_y_deg": 45.0})
|
||
_check(ObjectOps.snap_to_ground(doc) == 0, "flaches Terrain: alles steht schon (0 Änderungen)")
|
||
_flatten_terrain(doc, 65535) # Terrain überall auf max_height (50 m)
|
||
var h := SvmapDocument.terrain_height_at(doc, 10.0, 10.0)
|
||
_check(absf(h - 50.0) < 0.01, "Terrain-Höhe nach Heben: %.1f m" % h)
|
||
var changed := ObjectOps.snap_to_ground(doc)
|
||
_check(changed == 2, "2 schwebende Objekte erkannt")
|
||
var objects: Array = doc["objects"]
|
||
_check(absf(float(objects[0]["pos"][1]) - 50.0) < 0.01, "Objekt 1 steht auf dem Boden")
|
||
_check(absf(float(objects[1]["pos"][1]) - 50.0) < 0.01, "Objekt 2 steht auf dem Boden")
|
||
_check(ObjectOps.snap_to_ground(doc) == 0, "zweiter Klick: nichts mehr zu tun")
|
||
# Teilweise schwebend: nur das schwebende wird erfasst.
|
||
objects[0]["pos"][1] = 50.0
|
||
objects[1]["pos"][1] = 60.0
|
||
_check(ObjectOps.snap_to_ground(doc) == 1, "nur das schwebende Objekt wird gesnapt")
|
||
|
||
|
||
func _test_snap_to_ground_undo() -> void:
|
||
print("Testgruppe: Snap to Ground = EIN Undo-Eintrag")
|
||
var doc := SvmapDocument.create_new("Snap-Undo", 1024.0, "mittag")
|
||
var hist := ActionHistory.new()
|
||
hist.begin(doc)
|
||
(doc["objects"] as Array).append({"id": "bunker_concrete", "pos": [0.0, 0.0, 0.0], "scale": 1.0, "rot_y_deg": 0.0})
|
||
(doc["objects"] as Array).append({"id": "fence_metal", "pos": [4.0, 0.0, -2.0], "scale": 1.0, "rot_y_deg": 90.0})
|
||
_flatten_terrain(doc, 32768) # Terrain auf ~25 m
|
||
var before: Dictionary = hist.snapshot(["objects"])
|
||
var changed := ObjectOps.snap_to_ground(doc)
|
||
hist.commit("Alle Objekte auf Boden gesetzt (%d)" % changed, before, hist.snapshot(["objects"]))
|
||
var objects: Array = doc["objects"]
|
||
_check(changed == 2, "beide Objekte gesnapt")
|
||
_check(absf(float(objects[0]["pos"][1]) - 25.0) < 0.05, "Objekt 1 auf Terrain-Höhe")
|
||
hist.undo()
|
||
_check(absf(float(objects[0]["pos"][1]) - 0.0) < 0.0001, "undo: beide wieder schwebend (1 Schritt)")
|
||
_check(absf(float(objects[1]["pos"][1]) - 0.0) < 0.0001, "undo: Objekt 2 auch")
|
||
hist.redo()
|
||
_check(absf(float(objects[0]["pos"][1]) - 25.0) < 0.05 and absf(float(objects[1]["pos"][1]) - 25.0) < 0.05, "redo: wieder auf dem Boden")
|
||
|
||
|
||
# ------------------------------------------- setzen/drehen/verschieben/löschen —
|
||
|
||
func _test_crud_undo_all_objects() -> void:
|
||
print("Testgruppe: JEDES Bibliotheks-Objekt — setzen/drehen/verschieben/löschen + je Undo")
|
||
var manifest := _load_manifest()
|
||
var lib: Dictionary = manifest.get("objects", {})
|
||
var doc := SvmapDocument.create_new("CRUD-Test", 1024.0, "mittag")
|
||
var hist := ActionHistory.new()
|
||
hist.begin(doc)
|
||
var all_ok := true
|
||
var first := true
|
||
for oid in lib.keys():
|
||
var x := randf() * 100.0 - 50.0
|
||
var z := randf() * 100.0 - 50.0
|
||
var y := SvmapDocument.terrain_height_at(doc, x, z)
|
||
# setzen (+ Undo)
|
||
var before := hist.snapshot(["objects"])
|
||
var obj := {"id": oid, "pos": [x, y, z], "scale": 1.0, "rot_y_deg": 0.0}
|
||
(doc["objects"] as Array).append(obj)
|
||
hist.commit("Test: %s platzieren" % oid, before, hist.snapshot(["objects"]))
|
||
var objects: Array = doc["objects"]
|
||
if objects.size() != 1 or absf(float(objects[0]["pos"][1]) - y) > 0.0001:
|
||
all_ok = false
|
||
hist.undo()
|
||
if not (doc["objects"] as Array).is_empty():
|
||
all_ok = false
|
||
hist.redo()
|
||
if (doc["objects"] as Array).size() != 1:
|
||
all_ok = false
|
||
# drehen (+ Undo)
|
||
before = hist.snapshot(["objects"])
|
||
objects[0]["rot_y_deg"] = 90.0
|
||
hist.commit("Test: drehen", before, hist.snapshot(["objects"]), "rot:0")
|
||
hist.undo()
|
||
if absf(float(objects[0]["rot_y_deg"]) - 0.0) > 0.0001:
|
||
all_ok = false
|
||
hist.redo()
|
||
if absf(float(objects[0]["rot_y_deg"]) - 90.0) > 0.0001:
|
||
all_ok = false
|
||
# verschieben (+ Undo)
|
||
before = hist.snapshot(["objects"])
|
||
objects[0]["pos"] = [x + 3.0, y, z + 3.0]
|
||
hist.commit("Test: verschieben", before, hist.snapshot(["objects"]), "move:0")
|
||
hist.undo()
|
||
if absf(float(objects[0]["pos"][0]) - x) > 0.0001:
|
||
all_ok = false
|
||
hist.redo()
|
||
if absf(float(objects[0]["pos"][0]) - (x + 3.0)) > 0.0001:
|
||
all_ok = false
|
||
# löschen (+ Undo)
|
||
before = hist.snapshot(["objects"])
|
||
(doc["objects"] as Array).remove_at(0)
|
||
hist.commit("Test: löschen", before, hist.snapshot(["objects"]))
|
||
hist.undo()
|
||
if (doc["objects"] as Array).size() != 1:
|
||
all_ok = false
|
||
hist.redo()
|
||
if not (doc["objects"] as Array).is_empty():
|
||
all_ok = false
|
||
if first:
|
||
first = false
|
||
_check(all_ok, "alle %d Objekte: setzen/drehen/verschieben/löschen je mit Undo+Redo sauber" % lib.size())
|
||
|
||
|
||
# -------------------------------------------------------- svmap-Roundtrip ----
|
||
|
||
func _test_svmap_roundtrip_objects() -> void:
|
||
print("Testgruppe: svmap-Roundtrip — Objekte (ID + Pos/Rot/Scale) überleben Speichern/Laden")
|
||
var doc := SvmapDocument.create_new("Roundtrip", 1024.0, "abend")
|
||
_flatten_terrain(doc, 20000) # Terrain leicht erhöht (~15 m)
|
||
var objects: Array = doc["objects"]
|
||
objects.append({"id": "watchtower_wood", "pos": [10.0, SvmapDocument.terrain_height_at(doc, 10.0, 6.0), 6.0], "scale": 1.0, "rot_y_deg": 30.0})
|
||
objects.append({"id": "crate_wood", "pos": [-8.0, SvmapDocument.terrain_height_at(doc, -8.0, -4.0), -4.0], "scale": 2.0, "rot_y_deg": 0.0})
|
||
objects.append({"id": "tree_pine", "pos": [-20.0, SvmapDocument.terrain_height_at(doc, -20.0, 18.0), 18.0], "scale": 1.0, "rot_y_deg": 75.0})
|
||
objects.append({"id": "rock_large", "pos": [24.0, SvmapDocument.terrain_height_at(doc, 24.0, -18.0), -18.0], "scale": 0.5, "rot_y_deg": 180.0})
|
||
objects.append({"id": "bunker_concrete", "pos": [0.0, SvmapDocument.terrain_height_at(doc, 0.0, 40.0), 40.0], "scale": 1.0, "rot_y_deg": 270.0})
|
||
var manifest := _load_manifest()
|
||
SvmapIO.sign_map(doc) # Prüfsumme setzen → validate_map (inkl. V13) prüfbar
|
||
_check(SvmapIO.validate_map(doc, manifest).is_empty(), "Map mit 5 Objekten validiert sauber (V1–V14)")
|
||
|
||
var save1 := SvmapIO.save_to_file("user://test_library_roundtrip.svmap", doc)
|
||
_check(save1["ok"], "save_to_file ok: %s" % str(save1["errors"]))
|
||
var load1 := SvmapIO.load_from_file("user://test_library_roundtrip.svmap")
|
||
_check(load1["ok"], "load_from_file ok: %s" % str(load1["errors"]))
|
||
var doc2: Dictionary = load1["data"]
|
||
var objs2: Array = doc2["objects"]
|
||
var same := objs2.size() == objects.size()
|
||
if same:
|
||
for i in objects.size():
|
||
var a: Dictionary = objects[i]
|
||
var b: Dictionary = objs2[i]
|
||
if str(a["id"]) != str(b["id"]):
|
||
same = false
|
||
for k in 3:
|
||
if absf(float(a["pos"][k]) - float(b["pos"][k])) > 0.0001:
|
||
same = false
|
||
if absf(float(a["rot_y_deg"]) - float(b["rot_y_deg"])) > 0.0001:
|
||
same = false
|
||
if absf(float(a["scale"]) - float(b["scale"])) > 0.0001:
|
||
same = false
|
||
_check(same, "alle Objekte identisch zurück (ID, Pos, Rot, Scale)")
|
||
_check(SvmapIO.validate_map(doc2, manifest).is_empty(), "geladene Map validiert erneut sauber")
|
||
var save2 := SvmapIO.save_to_file("user://test_library_roundtrip2.svmap", doc2)
|
||
_check(save2["ok"], "zweites Speichern ok")
|
||
var text1 := FileAccess.get_file_as_string("user://test_library_roundtrip.svmap")
|
||
var text2 := FileAccess.get_file_as_string("user://test_library_roundtrip2.svmap")
|
||
_check(text1 == text2, "save→load→save byte-identisch")
|
||
# Poly-Budget-Rechnung kommt aus dem Katalog (Σ poly × scale²).
|
||
var expected := 0.0
|
||
for o in objects:
|
||
expected += float(manifest["objects"][str(o["id"])]["poly"]) * float(o["scale"]) * float(o["scale"])
|
||
_check(absf(SvmapDocument.poly_usage(doc, manifest) - expected) < 0.01,
|
||
"Poly-Budget aus Katalog: %.0f (erwartet %.0f)" % [SvmapDocument.poly_usage(doc, manifest), expected])
|
||
DirAccess.remove_absolute(ProjectSettings.globalize_path("user://test_library_roundtrip.svmap"))
|
||
DirAccess.remove_absolute(ProjectSettings.globalize_path("user://test_library_roundtrip2.svmap"))
|