Godot 4.8 Beta 3 Lançada? Execute Estes Testes de Migração Antes que Suas Cenas Quebrem
Em resumo
Rode os testes de migração do Godot 4.8 beta 3 antes que suas cenas quebrem: veja as principais armadilhas, scripts e como reportar regressões.
O snapshot da beta 3 do Godot 4.8 acabou de sair, e a equipe diz que está chegando perto da fase de release candidate. Isso significa que a janela para encontrar e reportar regressões está diminuindo rápido. Se você mantém um projeto Godot — seja lançando no próximo mês ou daqui a um ano — agora é a hora de abrir seu código neste build e ver o que quebra.
A maioria dos desenvolvedores não testa betas de forma sistemática. Eles clonam o build, abrem o projeto, dão uma olhada em algumas cenas e consideram suficiente. Aí a versão estável sai, a física fica diferente, os arquivos de save desserializam incorretamente, e um jogador encontra um erro obscuro de parsing de GDScript que nunca apareceu durante o desenvolvimento. A solução não é debugging heroico após o lançamento. É um protocolo de testes repetível que captura esses problemas agora.
Este guia oferece um fluxo de trabalho concreto: um script de teste de migração que você pode rodar hoje, três armadilhas específicas para verificar e uma estrutura de relatório de regressão que realmente chama a atenção da equipe do Godot.
Por Que a Beta 3 É Seu Prazo de Testes
A beta 3 é a última beta antes de a equipe do Godot passar para os release candidates. Release candidates servem para polimento, não para descobrir que move_and_slide() se comporta de forma diferente em inclinações acima de 45°. Quando a RC1 sair, novas regressões só serão triadas como blockers se forem graves o bastante para atrasar o lançamento.
Sua função durante a janela da beta é direta:
- Encontrar regressões antes que fiquem invisíveis no build estável
- Documentar mudanças que quebram o projeto específicas do seu código
- Reportar bugs com passos mínimos de reprodução para que os mantenedores possam corrigi-los
A equipe do Godot estava no GodotFest na semana passada e mesmo assim publicou correções para os blockers restantes. Esse é o ritmo. Se você quer ter voz no que o 4.8 será no lançamento, teste agora.
Configurando um Branch de Teste de Migração
Antes de abrir qualquer coisa na beta 3, crie um ambiente de teste limpo:
# Create a dedicated testing branch from your stable codebase
git checkout -b beta/4.8-testing
git push -u origin beta/4.8-testing
Por que um branch separado é importante: os arquivos de cena do Godot (.tscn) são baseados em texto e incluem metadados específicos da engine. Quando você abre uma cena na 4.8 beta 3 e salva, o hash do arquivo muda. Se você estiver fazendo merge com colegas que usam versões diferentes do Godot, isso cria conflitos de merge difíceis de resolver. Mantenha os testes da beta isolados.
Criando um Script de Teste de Migração
A maior lacuna de testes que os desenvolvedores enfrentam é não ter uma baseline. Você abre o projeto, ele "parece ok" e você segue em frente. O problema: parecer ok deixa passar drift de física, diferenças de compilação de shaders e mudanças de comportamento do GDScript que só aparecem em condições específicas.
Aqui está um script de teste de migração que você pode colocar em qualquer projeto Godot 4.x. Ele valida comportamentos centrais da engine contra valores esperados:
@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
Rode nos dois builds e compare a saída com diff:
# 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
Se o diff mostrar resultados idênticos de pass/fail, seus comportamentos centrais sobreviveram à atualização. Divergências apontam diretamente para a mudança de API.
Três Armadilhas de Migração para Verificar
Armadilha 1: Parsing de GDScript e Inferência de Tipos
O parser do GDScript recebe atualizações a cada release menor. No 4.8, fique atento a estas áreas específicas:
- Coerção de arrays tipados — o comportamento de conversão entre
Array[int]ePackedByteArrayfoi endurecido nas versões recentes. Se o seu código depende de conversão implícita entre arrays tipados e packed arrays, teste esses caminhos de código explicitamente. - Ordem de avaliação de scripts @tool — EditorScripts que dependem de uma ordem específica de inicialização podem se comportar de forma diferente se o timing do avaliador mudou.
- Sintaxe de conexão de sinais — o padrão
signal.connect(callable)está estável, mas conexões baseadas em string ("signal_name") estão deprecadas e podem emitir warnings ou erros.
# 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])
Abordagem de detecção: use grep no seu projeto para estes padrões:
# 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 ':'
Armadilha 2: Metadados de Arquivo de Cena
Quando você abre um arquivo .tscn no editor da 4.8 beta 3, a cena é salva novamente com metadados atualizados. A contagem de load_steps, os valores de uid e a ordem das seções [resource] podem mudar. Isso normalmente é inofensivo, mas quebra o git blame e piora os conflitos de merge.
Antes de abrir cenas na beta 3:
- Exporte os hashes atuais das suas cenas:
git ls-files '*.tscn' | xargs md5sum > scene_hashes_stable.txt - Abra o projeto na beta 3, navegue por algumas cenas e salve
- Re-exporte:
git ls-files '*.tscn' | xargs md5sum > scene_hashes_beta.txt - Compare:
diff scene_hashes_stable.txt scene_hashes_beta.txt
Se apenas os metadados mudaram (o conteúdo das suas cenas parece o mesmo, mas os arquivos estão diferentes), você já sabe o que esperar ao migrar na versão estável.
Armadilha 3: Desvio de Baseline na Simulação de Física
Mudanças de física são a categoria de regressão mais traiçoeira. Nada crasha. Nenhum erro aparece. Seu personagem apenas parece 2% mais lento, ou o arco do seu projétil fica 5 pixels mais baixo do que antes. Os jogadores podem não notar. Sua equipe de QA só vai perceber no teste de feel se estiver prestando atenção.
A solução — uma cena de teste de regressão de física:
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()
Registre a saída na estável 4.7.x. Registre-a na 4.8 beta 3. Se os números diferirem por mais de 1-2 pixels, você tem uma regressão de física que vale a pena reportar.
Testando Builds Exportados — A Parte que a Maioria dos Devs Pula
Testar no editor captura problemas de script e cena. Builds exportados têm sua própria classe de problemas:
| Plataforma | Área de Foco | Armadilha Comum no 4.x |
|---|---|---|
| Windows | Compilação de shaders, carregamento de DLL | Cache de shaders invalidado entre versões do Godot |
| Linux | Compatibilidade com driver Vulkan | Diferenças no driver Mesa com recursos do Vulkan 1.3 |
| Android | Latência de input touch, ciclo de vida do app | Pause/resume de Activity perdendo estado em versões mais novas do Android |
| Web | Limites de memória, performance do GDScript | Builds compilados com Emscripten têm teto de memória mais restrito |
| WebXR | Transições de modo imersivo | A limpeza ao sair da sessão pode diferir do XR desktop |
O teste de compatibilidade de exportação:
# 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
Rode cada build e execute um loop de gameplay padrão de 10 minutos. Preste atenção aos tempos de carregamento, ao frame rate e se surgem artefatos visuais que não existiam na versão estável.
Reportando Regressões Que São Corrigidas
O issue tracker do Godot recebe centenas de relatórios por release. Os que recebem um desenvolvedor designado rapidamente compartilham uma estrutura:
## 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].
Elementos-chave que tornam os relatórios acionáveis:
- Números específicos, não "parece mais lento"
- Hash do build no menu Help, não apenas "beta 3"
- Um único arquivo de cena que reproduza o problema sem o projeto inteiro
- Comparação com a estável mostrando valores exatos esperados vs. reais
- Informações de GPU e driver, já que problemas de renderização dependem do hardware
Se quiser fazer bisect do commit exato, clone o código-fonte do Godot e use git bisect. É a forma mais eficiente de identificar quando uma regressão foi introduzida e acelera drasticamente as correções.
Melhores Práticas para Sua Migração ao Godot 4.8
Mantenha um
MIGRATION-4.8.mdno seu repositório — Documente cada mudança de API que encontrar e cada diferença de comportamento, com a linha de GDScript e a solução alternativa. Quando a estável sair, você terá um guia de migração completo e específico do projeto, em vez de redescobrir problemas.Teste round-trips de save/load — Se o seu jogo serializa dados do jogador com
JSON.stringify()ouResourceSaver.save(), verifique se dados gravados com 4.7.x carregam corretamente na 4.8 beta 3 e vice-versa. Mudanças de formato na serialização podem corromper silenciosamente o progresso do jogador.Verifique a compatibilidade de addons — Se você usa plugins GDExtension ou addons GDScript da Asset Library, verifique os repositórios no GitHub para notas de compatibilidade com 4.8. Muitos mantenedores de addons não testam contra betas a menos que desenvolvedores peçam. Seja esse desenvolvedor.
Teste seu pipeline de CI — Se o seu projeto tem builds automatizados, atualize a versão do Godot no seu runner de CI para 4.8 beta 3 e execute o pipeline completo. Scripts de build que referenciam caminhos do editor ou flags de CLI podem quebrar se essas APIs mudaram.
Validação separada de renderização — Rode o jogo com
--rendering-driver vulkan,--rendering-driver opengl3e--rendering-driver d3d12(Windows) se aplicável. O comportamento dos rendering drivers diverge entre versões mais do que qualquer outro subsistema.
Quando Sua Stack de Backend Precisa Sobreviver à Atualização
Migrações de engine afetam mais do que o código de gameplay. Se o seu jogo armazena dados do jogador remotamente — tokens de autenticação, progresso salvo, envios de leaderboard — o formato de serialização entre cliente e backend precisa permanecer consistente.
Considere este cenário: o Godot 4.8 muda como JSON.stringify() lida com precisão de ponto flutuante em valores de Dictionary. Seu payload de cloud save muda de {"x": 100.5} para {"x": 100.499999}. Seu backend não se importa, mas se você está fazendo resolução de conflitos no cliente (comparando versões locais vs. remotas dos dados de save), essa diferença de epsilon causa conflitos de merge espúrios.
É por isso que sistemas de save cientes de revisão importam durante migrações de engine. horizOn fornece Cloud Save vinculado à conta com leituras e gravações cientes de revisão, onde o cliente lida com a resolução de conflitos. Quando o comportamento de serialização da sua engine muda entre versões, um sistema ciente de revisão evita os conflitos fantasma que a comparação baseada em igualdade provocaria.
Seus Próximos Passos
- Baixe o Godot 4.8 beta 3 pelo snapshot oficial ou experimente o editor web para um smoke test rápido
- Crie seu branch de testes e rode os scripts de teste de migração acima
- Abra suas cenas mais complexas e verifique se continuam com aparência e comportamento corretos
- Exporte e teste nas suas plataformas-alvo — não apenas no editor
- Registre regressões no rastreador de issues do Godot no GitHub com passos mínimos de reprodução
A versão estável vai chegar, você teste ou não. Os desenvolvedores que validam contra as betas lançam no primeiro dia. Os demais ficam debugando problemas de produção durante a janela de lançamento.