From 7a1b5037e7ef2134ee94390c494cbeb700ecdffa Mon Sep 17 00:00:00 2001 From: "Hermes (scopedvr-dev)" Date: Tue, 20 Oct 2026 21:21:02 +0000 Subject: [PATCH] Playtest: Splitter-Lagen bleiben erhalten (Sly-Befund 20.10.) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Beim Start des Test-Modus versteckt der Editor die Panels — Godot klappt dabei die Splitter zusammen (Lage springt z. B. [-320,0] → [160]), beim Wiedereinblenden baut er die Trenner mit Defaults wieder auf → die fein gezogenen Seitenbereiche waren weg („riesen groß"). Fix in main.gd (besitzt die UI, überlebt den Playtest-Node): beim Start alle split_offsets von MainSplit/BottomSplit sichern, im Exit-Handler deferred UND im nächsten Frame zurücksetzen (das Layout muss die Panels erst neu vermessen haben). Suite test_playtest 52/52 (mit Splitter-Regression: merken → verbiegen → Exit → unverändert), test_ui_layout 79, test_gui_smoke 92 grün. --- src/ui/main.gd | 25 +++++++++++++++++++++++++ tests/test_playtest.gd | 40 ++++++++++++++++++++++++++++++++++++++++ 2 files changed, 65 insertions(+) diff --git a/src/ui/main.gd b/src/ui/main.gd index fdbfa58..7157009 100644 --- a/src/ui/main.gd +++ b/src/ui/main.gd @@ -187,6 +187,7 @@ var test_btn: Button # U1-Dock-Zustand: Splitter-Lagen ([fenster]-Abschnitt, gemerkt) var _dock_offsets: Dictionary = {} +var _split_lagen_playtest: Dictionary = {} # Playtest: Trenner-Lagen (Sly-Befund 20.10.) const GizmoScript := preload("res://src/viewport/gizmo.gd") const INSPECTOR_PANEL := preload("res://src/ui/inspector_panel.gd") @@ -1105,6 +1106,14 @@ func _start_playtest() -> void: Input.mouse_mode = Input.MOUSE_MODE_CAPTURED playtest = load("res://src/editor/playtest/playtest_mode.gd").new() playtest.ui_panels = [ui_top_bar, ui_left_panel, ui_right_panel, ui_status_bar] + # Trenner-Lagen JETZT sichern (Sly-Befund 20.10.: beim Verstecken der + # Panels klappen die Trenner zusammen — nach dem Playtest mussten die + # Seitenbereiche neu gezogen werden). Wiederherstellung im Exit-Handler. + _split_lagen_playtest.clear() + for sname in ["MainSplit", "BottomSplit"]: + var sp := _find_split(sname) + if sp != null: + _split_lagen_playtest[sname] = sp.split_offsets.duplicate() playtest.ui_status = status_label playtest.help_label = help_label playtest.exit_requested.connect(_on_playtest_exit_requested) @@ -1146,6 +1155,22 @@ func _on_playtest_exit_requested() -> void: tool_mode = _playtest_tool_mode _update_tool_label() _set_status("Testlauf beendet — zurück im Editor (Auswahl und Dokument unverändert).") + # Trenner-Lagen zurücksetzen (Sly-Befund 20.10.): das Re-Layout nach dem + # Wiedereinblenden der Panels setzt die Trenner auf Defaults — die gemerkten + # Lagen deshalb deferred UND im nächsten Frame zurücksetzen (das Layout + # muss die Panels erst neu vermessen haben, sonst clampen sie erneut). + _playtest_split_lagen_zurueck.call_deferred() + get_tree().process_frame.connect(_playtest_split_lagen_zurueck, CONNECT_ONE_SHOT) + + +## Gemerkte Playtest-Trenner-Lagen zurück auf die Splitter schreiben. +func _playtest_split_lagen_zurueck() -> void: + if _split_lagen_playtest.is_empty(): + return + for sname in _split_lagen_playtest.keys(): + var sp := _find_split(str(sname)) + if sp != null: + sp.split_offsets = _split_lagen_playtest[sname] func _on_new_map_confirmed() -> void: diff --git a/tests/test_playtest.gd b/tests/test_playtest.gd index 31af635..297c2cf 100644 --- a/tests/test_playtest.gd +++ b/tests/test_playtest.gd @@ -58,7 +58,9 @@ func _run_all() -> void: main.call("_refresh_all") await process_frame + _test_splitter_lagen_merken() _test_start_state() + _test_splitter_lagen_verbiegen() await _test_terrain_height_matches_document() await _test_wall_blocks_player() await _test_step_up_semantics() @@ -66,6 +68,7 @@ func _run_all() -> void: await _test_yaw_relatives_laufen() await _test_bauteile_treppe_tuer() _test_exit_restores_editor() + await _test_splitter_lagen_pruefen() _finish() @@ -366,6 +369,43 @@ func _test_yaw_relatives_laufen() -> void: _check(d1.x < -1.0 and absf(d1.z) < 0.6, "yaw 90° + W → Bewegung folgt Blick nach -X (d=%.1f, %.1f)" % [d1.x, d1.z]) +## --- Test 6b: Splitter-Lagen überleben den Playtest (Sly-Befund 20.10.) ----- +## Beim Verstecken der Panels klappen die Trenner zusammen; der Exit muss die +## gemerkten Lagen zurücksetzen. Der Test verbiegt die Lagen bewusst hart +## (wie der Clamp es tut) und verlangt nach dem Exit die Original-Lagen. +var _split_vor_start: Dictionary = {} + +func _split_by_name(sname: String) -> SplitContainer: + var found := root.find_children(sname, "SplitContainer", true, false) + return found[0] if not found.is_empty() else null + +func _test_splitter_lagen_merken() -> void: + # Bezugspunkt = VOR dem Start (nach dem Start klappen die Trenner bereits). + for sname in ["MainSplit", "BottomSplit"]: + var sp := _split_by_name(sname) + if sp != null: + _split_vor_start[sname] = Array(sp.split_offsets) + +func _test_splitter_lagen_verbiegen() -> void: + var ms := _split_by_name("MainSplit") + if ms != null: + ms.split_offsets = PackedInt32Array([9999, 9999]) + var bs := _split_by_name("BottomSplit") + if bs != null: + bs.split_offsets = PackedInt32Array([-9999]) + +func _test_splitter_lagen_pruefen() -> void: + for i in 3: + await process_frame + var ok := true + for sname in _split_vor_start.keys(): + var sp := _split_by_name(str(sname)) + if sp == null or Array(sp.split_offsets) != _split_vor_start[sname]: + ok = false + print(" DIFF ", sname, ": ", str(sp.split_offsets if sp != null else null), + " statt ", str(_split_vor_start[sname])) + _check(ok, "Splitter-Lagen nach Playtest unverändert (Sly-Befund)") + ## --- Test 6: Rückkehr stellt den Editor-Zustand wieder her ------------------ func _test_exit_restores_editor() -> void: print("Testgruppe: Rückkehr in den Editor (Dokument + Undo unverändert)")