Powrót do Bloga

Godot 4.8 Beta 3 wychodzi? Przeprowadź te testy migracyjne, zanim Twoje sceny się zepsują

Opublikowano 13 listopada 2026
Godot 4.8 Beta 3 wychodzi? Przeprowadź te testy migracyjne, zanim Twoje sceny się zepsują Wygenerowano przy użyciu AI

W skrócie

Przetestuj już migrację do Godota 4.8 beta 3: skrypty testowe, pułapki GDScript i fizyki oraz skuteczne zgłaszanie regresji przed premierą wersji.

Snapshot Godot 4.8 beta 3 właśnie się ukazał, a zespół zapowiada, że zbliża się do fazy kandydatów do wydania. To oznacza, że okno na znalezienie i zgłoszenie regresji szybko się zamyka. Jeśli utrzymujesz projekt w Godocie — niezależnie od tego, czy premiera jest za miesiąc, czy za rok — teraz jest czas, aby otworzyć swój kod w tym buildzie i sprawdzić, co się psuje.

Większość deweloperów nie testuje bet systematycznie. Klonują build, otwierają projekt, rzucają okiem na kilka scen i uznają, że jest dobrze. Potem wychodzi wersja stabilna, fizyka działa inaczej, pliki zapisu deserializują się niepoprawnie, a gracz trafia na niejasny błąd parsowania GDScript, który nigdy nie ujawnił się podczas prac. Rozwiązaniem nie jest heroiczne debugowanie po premierze. To powtarzalny protokół testowania, który wyłapie te problemy teraz.

Ten przewodnik przedstawia konkretny workflow: skrypt testów migracyjnych, który możesz uruchomić dziś, trzy konkretne pułapki, na które warto uważać, oraz strukturę zgłaszania regresji, która faktycznie przyciąga uwagę zespołu Godota.


Dlaczego Beta 3 to Twój termin na testy

Beta 3 to ostatnia beta, zanim zespół Godota przejdzie do kandydatów do wydania. Kandydaci do wydania służą do polerowania, a nie do odkrywania, że move_and_slide() zachowuje się inaczej na zboczach nachylonych pod kątem większym niż 45°. Gdy RC1 trafi do rąk użytkowników, nowe regresje będą klasyfikowane jako blokery tylko wtedy, gdy będą na tyle poważne, by opóźnić wydanie.

Twoje zadanie w oknie bety jest proste:

  • Znajdź regresje, zanim staną się niewidoczne w wersji stabilnej
  • Udokumentuj breaking changes specyficzne dla kodu Twojego projektu
  • Zgłaszaj błędy z minimalnymi krokami reprodukcji, aby opiekunowie mogli je naprawić

Zespół Godota był w zeszłym tygodniu na GodotFest i wciąż wdrażał poprawki dla pozostałych blokerów wydania. Takie jest tempo. Jeśli chcesz mieć wpływ na to, jak 4.8 będzie wyglądać przy premierze, testuj teraz.


Konfiguracja gałęzi do testów migracyjnych

Zanim otworzysz cokolwiek w becie 3, utwórz czyste środowisko testowe:

# Create a dedicated testing branch from your stable codebase
git checkout -b beta/4.8-testing
git push -u origin beta/4.8-testing

Dlaczego osobna gałąź ma znaczenie: Pliki scen Godota (.tscn) są tekstowe i zawierają metadane specyficzne dla silnika. Gdy otworzysz scenę w 4.8 beta 3 i zapiszesz ją, hash pliku się zmienia. Jeśli scalasz zmiany z członkami zespołu pracującymi na różnych wersjach Godota, powstają konflikty scalania, które są bolesne do rozwiązania. Trzymaj testy bety w izolacji.


Tworzenie skryptu testów migracyjnych

Największą luką testową, na jaką trafiają deweloperzy, jest brak punktu odniesienia. Otwierasz projekt, „wygląda dobrze” i ruszasz dalej. Problem: wyglądanie dobrze pomija dryf fizyki, różnice w kompilacji shaderów i zmiany zachowania GDScript, które ujawniają się tylko w określonych warunkach.

Oto skrypt testów migracyjnych, który możesz wrzucić do dowolnego projektu Godot 4.x. Weryfikuje podstawowe zachowania silnika względem oczekiwanych wartości:

@tool
extends SceneTree

## Godot 4.8 Beta 3 Migration Test Suite
## Run with: godot --headless -s migration_test.gd
##
## This script validates that core engine behaviors match
## expectations from Godot 4.7.x stable. Run it in both
## the stable build and beta 3, then compare output.

var results: Array[Dictionary] = []

func _init() -> void:
	print("\n╔══════════════════════════════════════════════╗")
	print("║   Godot 4.8 Beta 3 — Migration Test Suite   ║")
	print("╚══════════════════════════════════════════════╝\n")
	
	test_vector_math()
	test_json_parsing()
	test_scene_serialization()
	test_input_map_registration()
	test_color_conversion()
	test_file_access_permissions()
	
	print_summary()
	quit(get_exit_code())

func record(test_name: String, passed: bool, detail: String) -> void:
	results.append({
		"name": test_name,
		"passed": passed,
		"detail": detail
	})

func test_vector_math() -> void:
	# Vector2 operations — regression-prone area in minor releases
	var a := Vector2(3.0, 4.0)
	var b := Vector2(1.0, 0.0)
	
	# Length should be exactly 5.0
	record(
		"Vector2.length()",
		abs(a.length() - 5.0) < 0.001,
		"Expected 5.0, got %.6f" % a.length()
	)
	
	# Normalized vector should have length 1.0
	var normalized := a.normalized()
	record(
		"Vector2.normalized()",
		abs(normalized.length() - 1.0) < 0.001,
		"Expected length 1.0, got %.6f" % normalized.length()
	)
	
	# Dot product: (3,4)·(1,0) = 3.0
	record(
		"Vector2.dot()",
		abs(a.dot(b) - 3.0) < 0.001,
		"Expected 3.0, got %.6f" % a.dot(b)
	)

func test_json_parsing() -> void:
	var test_cases := [
		'{"score": 1500, "level": 12, "name": "TestPlayer"}',
		'{"nested": {"value": true}, "array": [1, 2, 3]}',
		'{"special": "chars: \\\"quotes\\\" and \\\\backslash"}',
	]
	
	for i in test_cases.size():
		var json := JSON.new()
		var error := json.parse(test_cases[i])
		record(
			"JSON.parse() case %d" % i,
			error == OK and json.data is Dictionary,
			"Parse error: %s" % error_string(error) if error != OK else "Parsed successfully with %d keys" % json.data.size()
		)

func test_scene_serialization() -> void:
	# Create a minimal scene and verify round-trip serialization
	var root := Node.new()
	root.name = "TestRoot"
	
	var child := Node2D.new()
	child.name = "TestChild"
	child.position = Vector2(100.5, 200.75)
	child.rotation = 1.5708  # ~90 degrees
	child.scale = Vector2(2.0, 2.0)
	root.add_child(child)
	
	# Test that properties are preserved
	record(
		"Node2D.position precision",
		abs(child.position.x - 100.5) < 0.01 and abs(child.position.y - 200.75) < 0.01,
		"Expected (100.5, 200.75), got (%.2f, %.2f)" % [child.position.x, child.position.y]
	)
	
	record(
		"Node2D.rotation",
		abs(child.rotation - 1.5708) < 0.001,
		"Expected ~1.5708, got %.6f" % child.rotation
	)
	
	root.free()

func test_input_map_registration() -> void:
	var action_name := "__migration_test_action_7f3a"
	var event := InputEventKey.new()
	event.keycode = KEY_SPACE
	
	InputMap.add_action(action_name)
	InputMap.action_add_event(action_name, event)
	
	record(
		"InputMap.add_action()",
		InputMap.has_action(action_name),
		"Action registered: %s" % InputMap.has_action(action_name)
	)
	
	var events := InputMap.action_get_events(action_name)
	record(
		"InputMap.action_get_events()",
		events.size() == 1 and events[0] is InputEventKey,
		"Expected 1 InputEventKey, got %d event(s)" % events.size()
	)
	
	InputMap.erase_action(action_name)
	record(
		"InputMap.erase_action()",
		not InputMap.has_action(action_name),
		"Action erased: %s" % (not InputMap.has_action(action_name))
	)

func test_color_conversion() -> void:
	# Colors can serialize differently across versions
	var red := Color(1.0, 0.0, 0.0, 1.0)
	var hex := red.to_html()
	
	record(
		"Color.to_html()",
		hex == "ff0000ff",
		"Expected 'ff0000ff', got '%s'" % hex
	)
	
	var from_html := Color.html("00ff00ff")
	record(
		"Color.html()",
		abs(from_html.g - 1.0) < 0.001 and abs(from_html.a - 1.0) < 0.001,
		"Expected green (0,1,0,1), got (%.2f, %.2f, %.2f, %.2f)" % [from_html.r, from_html.g, from_html.b, from_html.a]
	)

func test_file_access_permissions() -> void:
	# Verify user:// directory is writable
	var test_path := "user://_migration_test.tmp"
	var file := FileAccess.open(test_path, FileAccess.WRITE)
	record(
		"FileAccess user:// write",
		file != null if true else FileAccess.get_open_error() == OK,
		"File opened for writing: %s" % ("OK" if file != null else error_string(FileAccess.get_open_error()))
	)
	
	if file:
		file.store_string("migration_test_4.8_beta3")
		file.close()
		
		# Read it back
		var reader := FileAccess.open(test_path, FileAccess.READ)
		if reader:
			var content := reader.get_as_text()
			reader.close()
			record(
				"FileAccess user:// read",
				content == "migration_test_4.8_beta3",
				"Read back: '%s'" % content
			)
		
		DirAccess.remove_absolute(test_path)

func print_summary() -> void:
	var passed_count := 0
	for result in results:
		var icon := "✅" if result["passed"] else "❌"
		print("%s  %s: %s" % [icon, result["name"], result["detail"]])
		if result["passed"]:
			passed_count += 1
	
	print("\n────────────────────────────────────────────")
	print("Results: %d / %d tests passed" % [passed_count, results.size()])
	
	if passed_count < results.size():
		var failed := results.size() - passed_count
		print("⚠️  %d test(s) failed." % failed)
		print("   Compare output against Godot 4.7.1 stable.")
		print("   File regressions: https://github.com/godotengine/godot/issues")
	else:
		print("✅  All core behaviors match expected values.")
		print("   This does NOT guarantee full compatibility,")
		print("   but it confirms fundamental APIs are stable.")

func get_exit_code() -> int:
	for result in results:
		if not result["passed"]:
			return 1
	return 0

Uruchom go w obu buildach i porównaj wyniki:

# In Godot 4.7.1 stable:
godot --headless -s migration_test.gd > results_stable.txt

# In Godot 4.8 beta 3:
godot --headless -s migration_test.gd > results_beta3.txt

# Compare:
diff results_stable.txt results_beta3.txt

Jeśli diff pokazuje identyczne wyniki pass/fail, Twoje podstawowe zachowania przetrwały aktualizację. Rozbieżności wskażą Ci bezpośrednio zmianę API.


Trzy pułapki migracyjne, na które warto uważać

Pułapka 1: Parsowanie GDScript i inferencja typów

Parser GDScript otrzymuje aktualizacje w każdej mniejszej wersji. W 4.8 zwróć uwagę na te konkretne obszary:

  • Wymuszanie tablic typowanych — zachowanie konwersji Array[int] vs PackedByteArray zostało zaostrzone w najnowszych wersjach. Jeśli Twój kod polega na niejawnej konwersji między tablicami typowanymi a upakowanymi, przetestuj te ścieżki kodu jawnie.
  • Kolejność ewaluacji skryptów @tool — EditorScripty zależne od konkretnej kolejności inicjalizacji mogą zachowywać się inaczej, jeśli zmienił się timing ewaluatora.
  • Składnia łączenia sygnałów — wzorzec signal.connect(callable) jest stabilny, ale połączenia oparte na stringach ("signal_name") są przestarzałe i mogą emitować ostrzeżenia lub błędy.
# Check your project for these patterns:

# AVOID — string-based signal connections (deprecated):
# node.connect("body_entered", self, "_on_body_entered")

# USE — callable-based connections:
node.body_entered.connect(_on_body_entered)

# AVOID — implicit typed array coercion:
var bytes: PackedByteArray = [72, 101, 108]  # May warn in 4.8

# USE — explicit construction:
var bytes: PackedByteArray = PackedByteArray([72, 101, 108])

Podejście do wykrywania: Przeszukaj projekt grepem pod kątem tych wzorców:

# Find deprecated signal connections
grep -rn '\.connect("' --include="*.gd" .

# Find string-based export hints
grep -rn 'export(' --include="*.gd" .

# Find untyped variables that may trigger new warnings
grep -rn 'var [a-z_]* =' --include="*.gd" . | grep -v ':'

Pułapka 2: Metadane plików scen

Gdy otworzysz plik .tscn w edytorze 4.8 beta 3, scena zostanie zapisana ponownie ze zaktualizowanymi metadanymi. Liczba load_steps, wartości uid i kolejność sekcji [resource] mogą się zmienić. Zwykle jest to nieszkodliwe, ale psuje git blame i pogarsza konflikty scalania.

Zanim otworzysz sceny w becie 3:

  1. Wyeksportuj aktualne hashe scen: git ls-files '*.tscn' | xargs md5sum > scene_hashes_stable.txt
  2. Otwórz projekt w becie 3, przejrzyj kilka scen, zapisz
  3. Wyeksportuj ponownie: git ls-files '*.tscn' | xargs md5sum > scene_hashes_beta.txt
  4. Porównaj: diff scene_hashes_stable.txt scene_hashes_beta.txt

Jeśli zmieniły się tylko metadane (zawartość scen wygląda tak samo, ale pliki się różnią), wiesz, czego się spodziewać podczas migracji na wersji stabilnej.

Pułapka 3: Dryf bazowy symulacji fizyki

Zmiany fizyki to najpodstępniejsza kategoria regresji. Nic się nie wywala. Nie pojawiają się żadne błędy. Twoja postać po prostu czuje się 2% wolniejsza, albo pocisk leci 5 pikseli niżej niż wcześniej. Gracze mogą tego nie zauważyć. Twój zespół QA wyłapie to w testach wrażeń tylko wtedy, gdy będzie uważny.

Rozwiązanie — scena testowa regresji fizyki:

extends Node2D

## Physics Regression Test — Godot 4.8 Beta 3
## Attach this to a Node2D in an empty scene.
## Run the scene and compare the printed positions
## against values from your stable build.

func _ready() -> void:
	await get_tree().create_timer(0.1).timeout
	run_gravity_test()
	run_velocity_test()

func run_gravity_test() -> void:
	var body := CharacterBody2D.new()
	var collision := CollisionShape2D.new()
	var shape := RectangleShape2D.new()
	shape.size = Vector2(16, 32)
	collision.shape = shape
	body.add_child(collision)
	add_child(body)
	
	body.position = Vector2(200, 100)
	body.velocity = Vector2.ZERO
	
	# Simulate 1 second of free fall (60 physics frames)
	for i in range(60):
		body.velocity.y += body.get_gravity().y * (1.0 / 60.0)
		body.move_and_slide()
		await get_tree().physics_frame
	
	var fall_distance := body.position.y - 100.0
	print("[Gravity Test] Fell %.2f pixels in 60 frames" % fall_distance)
	print("  Compare against stable build — deviation > 1.0 px = investigate")
	print("  Expected range: 489.0 - 491.0 (default gravity 980 px/s²)")
	
	body.queue_free()

func run_velocity_test() -> void:
	var body := CharacterBody2D.new()
	var collision := CollisionShape2D.new()
	var shape := RectangleShape2D.new()
	shape.size = Vector2(16, 32)
	collision.shape = shape
	body.add_child(collision)
	add_child(body)
	
	body.position = Vector2(50, 300)
	body.velocity = Vector2(300, 0)
	
	# Move horizontally for 2 seconds
	for i in range(120):
		body.velocity = Vector2(300, 0)
		body.move_and_slide()
		await get_tree().physics_frame
	
	var horizontal_distance := body.position.x - 50.0
	print("[Velocity Test] Moved %.2f pixels horizontally in 120 frames" % horizontal_distance)
	print("  Expected: ~600.0 px (300 px/s × 2 seconds)")
	print("  Deviation > 2.0 px = physics engine behavior changed")
	
	body.queue_free()

Zanotuj wyniki ze stabilnej 4.7.x. Zanotuj wyniki z 4.8 beta 3. Jeśli liczby różnią się o więcej niż 1-2 piksele, masz regresję fizyki wartą zgłoszenia.


Testowanie wyeksportowanych buildów — część, którą większość deweloperów pomija

Testowanie w edytorze wyłapuje problemy ze skryptami i scenami. Wyeksportowane buildy mają własną klasę problemów:

Platforma Obszar zainteresowania Typowa pułapka 4.x
Windows Kompilacja shaderów, ładowanie DLL Cache shaderów unieważniany między wersjami Godota
Linux Kompatybilność sterowników Vulkan Różnice w sterownikach Mesa z funkcjami Vulkan 1.3
Android Latencja dotyku, cykl życia aplikacji Pauza/wznowienie aktywności gubiące stan w nowszych wersjach Androida
Web Limity pamięci, wydajność GDScript Buildy kompilowane przez Emscripten mają ostrzejszy limit pamięci
WebXR Przejścia trybu immersyjnego Czyszczenie po wyjściu z sesji może różnić się od desktopowego XR

Test kompatybilności eksportu:

# Export your project for each target platform
# Save the export output with the Godot version in the filename

# Windows
godot --headless --export-release "Windows Desktop" build/godot471_win.exe
# Then repeat with beta 3:
godot --headless --export-release "Windows Desktop" build/godot48b3_win.exe

# Android APK
godot --headless --export-release "Android" build/godot471_android.apk
godot --headless --export-release "Android" build/godot48b3_android.apk

Uruchom każdy build i wykonaj standardową 10-minutową pętlę rozgrywki. Zwróć uwagę na czasy ładowania, liczbę klatek i to, czy pojawiają się artefakty wizualne, których nie było w wersji stabilnej.


Zgłaszanie regresji, które zostają naprawione

Tracker zgłoszeń Godota otrzymuje setki raportów na wydanie. Te, które szybko dostają przypisanego dewelopera, mają wspólną strukturę:

## Summary
CharacterBody2D.move_and_slide() produces 3.2% less vertical displacement 
on slopes steeper than 45° compared to Godot 4.7.1 stable.

## Environment
- OS: Windows 11, NVIDIA RTX 3070, driver 551.86
- Godot build: 4.8-beta3 (build hash from Help → Copy Build Info)
- Rendering method: Forward+

## Minimal Reproduction
1. Open attached project
2. Run scene `test_slope_regression.tscn`
3. Observe printed displacement: 456.2 px (expected: 471.3 px)

## Regression Marker
Verified behavior in Godot 4.7.1 stable: displacement is 471.3 px.
Likely introduced between commit [first known good] and [first known bad].

Kluczowe elementy, które czynią raporty przydatnymi:

  • Konkretne liczby, a nie „wydaje się wolniejsze”
  • Hash builda z menu Help, a nie tylko „beta 3”
  • Pojedynczy plik sceny, który reprodukuje problem bez całego projektu
  • Porównanie z wersją stabilną pokazujące dokładne wartości oczekiwane vs. rzeczywiste
  • Informacje o GPU i sterowniku, ponieważ problemy z renderowaniem zależą od sprzętu

Jeśli chcesz wykonać bisect dokładnego commita, sklonuj źródła Godota i użyj git bisect. To najskuteczniejszy sposób na zlokalizowanie momentu wprowadzenia regresji i znacznie przyspiesza naprawy.


Najlepsze praktyki dla Twojej migracji do Godota 4.8

  1. Trzymaj MIGRATION-4.8.md w swoim repo — Każdą zmianę API, każdą różnicę w zachowaniu, udokumentuj z linią GDScript i obejściem. Gdy wyjdzie wersja stabilna, będziesz mieć kompletny, projektowo-specyficzny przewodnik migracji zamiast odkrywać problemy na nowo.

  2. Przetestuj round-tripy zapisu/odczytu — Jeśli Twoja gra serializuje dane gracza przez JSON.stringify() lub ResourceSaver.save(), zweryfikuj, że dane zapisane w 4.7.x ładują się poprawnie w 4.8 beta 3 i odwrotnie. Zmiany formatu serializacji mogą po cichu uszkodzić postępy graczy.

  3. Sprawdź kompatybilność dodatków — Jeśli używasz wtyczek GDExtension lub dodatków GDScript z Asset Library, sprawdź ich repozytoria GitHub pod kątem notatek o kompatybilności z 4.8. Wielu opiekunów dodatków nie testuje bet, dopóki deweloperzy o to nie poproszą. Bądź tym deweloperem.

  4. Przetestuj swój pipeline CI — Jeśli Twój projekt ma zautomatyzowane buildy, zaktualizuj wersję Godota w swoim runnerze CI do 4.8 beta 3 i uruchom cały pipeline. Skrypty buildów odwołujące się do ścieżek edytora lub flag CLI mogą się zepsuć, jeśli te API się zmieniły.

  5. Osobna walidacja renderowania — Uruchom grę z --rendering-driver vulkan, --rendering-driver opengl3 i --rendering-driver d3d12 (Windows), jeśli to dotyczy. Zachowanie sterowników renderowania różni się między wersjami bardziej niż jakikolwiek inny podsystem.


Gdy Twój stack backendowy musi przetrwać aktualizację

Migracje silnika wpływają na więcej niż tylko kod rozgrywki. Jeśli Twoja gra przechowuje dane graczy zdalnie — tokeny uwierzytelniania, zapisane postępy, zgłoszenia do tablic wyników — format serializacji między klientem a backendem musi pozostać spójny.

Rozważ taki scenariusz: Godot 4.8 zmienia sposób, w jaki JSON.stringify() obsługuje precyzję zmiennoprzecinkową w wartościach Dictionary. Twój payload zapisu w chmurze zmienia się z {"x": 100.5} na {"x": 100.499999}. Twój backend nie przejmuje się tym, ale jeśli robisz rozwiązywanie konfliktów po stronie klienta (porównywanie lokalnych i zdalnych wersji danych zapisu), ta różnica epsilon powoduje pozorne konflikty scalania.

Dlatego systemy zapisu z obsługą rewizji mają znaczenie podczas migracji silnika. horizOn zapewnia Cloud Save przypisany do konta z odczytami i zapisami uwzględniającymi rewizje, gdzie klient obsługuje rozwiązywanie konfliktów. Gdy zachowanie serializacji Twojego silnika zmienia się między wersjami, system z obsługą rewizji unika widmowych konfliktów, które wywołałoby porównanie oparte na równości.


Twoje następne kroki

  1. Pobierz Godot 4.8 beta 3 z oficjalnego snapshota lub wypróbuj edytor webowy do szybkiego testu dymnego
  2. Utwórz swoją gałąź testową i uruchom powyższe skrypty testów migracyjnych
  3. Otwórz swoje najbardziej złożone sceny i zweryfikuj, czy nadal wyglądają i działają poprawnie
  4. Wyeksportuj i przetestuj na docelowych platformach — nie tylko w edytorze
  5. Zgłoś regresje w trackerze zgłoszeń Godot na GitHub z minimalnymi krokami reprodukcji

Wersja stabilna nadejdzie, niezależnie od tego, czy testujesz, czy nie. Deweloperzy, którzy walidują bety, wdrażają grę w dniu premiery. Reszta debuguje problemy produkcyjne w oknie startowym.


Źródło: Snapshot deweloperski: Godot 4.8 beta 3