Replace M* table-wrapper classes with typed Resources; add type hints

Two related cleanups from the best-practice audit:

Task 3 — typed Resources instead of MBase / MScene / MLevel / MSetting

The old model classes wrapped the godot_db_manager Table API: each row
read went through table.get_data_at_row_idx(int), Cell.get_data(),
and 'as int' / 'as String' casts that don't actually parse anything
in Godot 4. m_value, m_lock, m_label, ... members shadowed the cell
indirection. Setters round-tripped through table.edit_data() +
Global.database.save_db(). That's a lot of plumbing for what is, in
the end, three flat tables of static strings.

Introduce three @export-typed Resources:
  db/scene_entry.gd     class_name SceneEntry
  db/level_entry.gd     class_name LevelEntry
  db/settings_data.gd   class_name SettingsData

Rewrite scripts/Database.gd so Database.DB holds:
  settings: SettingsData
  levels:   Array[LevelEntry]
  scenes:   Array[SceneEntry]

Build them once at startup from ahog.json, and serialise back to the
same JSON shape on save() so existing progress files keep working.
LevelEntry carries its own object_to_find / object_finding / reset
methods (talking to Global.database for cross-table lookups), and
SceneEntry carries its own mesh_path / audio_sound. Per-scene
dissolve state (value, tick_reference, dissolved) lives on
SceneEntry as non-exported runtime fields.

Delete db/MBase.gd / db/MScene.gd / db/MLevel.gd / db/MSetting.gd.

Update consumers:
- scripts/Setting.gd: read/write Global.database.settings directly,
  call Global.database.save() after each setter.
- scenes/levels/Levels.gd: iterate Global.database.scenes_for_level(
  current_scene_int) instead of mscene.new(i) for every row; scene
  state reads (scene.lock, scene.mesh, scene.counter, ...) replace
  scene.lock() / scene.mesh() / scene.counter() method calls; runtime
  dissolve state lives on the SceneEntry instance instead of mutable
  m_value / m_tick_reference members on MScene; 'dissolved' flag
  replaces set_mesh(null) signalling.
- scenes/UI/choose_scenes/ChooseScene.gd: iterate Global.database
  .levels; level.name / level.thumb property access in place of
  level.name() / level.thumbnail(). configure_reset() loses its
  redundant index argument (LevelEntry knows its own index).
- scripts/event.gd: _on_reset_level signature now takes LevelEntry,
  reset path drops index forwarding.

Task 2 — type hints across the remaining scripts

scripts/Global.gd, scenes/Main.gd, scenes/UI/ending/Ending.gd,
scenes/UI/loading/Loading.gd, scenes/UI/settings/Settings.gd: add
typed parameters and -> return annotations. current_scene_int is now
'int = -1' (sentinel) so callers don't fall into Variant comparisons;
event.gd:_on_reset_level resets it to -1 instead of null.
Settings.gd no longer wraps button_pressed in int() before passing to
the now-typed bool setters.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

scripts/Database.gd

@@ -1,128 +1,155 @@
 extends Node
 
-# Lightweight replacement for the godot_db_manager plugin (incompatible with
-# Godot 4). Keeps the ahog.json format used by the rest of the project and
-# exposes the same surface API the M* model classes expect:
+# Loads ahog.json once into typed Resource arrays:
+#   Global.database.settings  -> SettingsData
+#   Global.database.levels    -> Array[LevelEntry]
+#   Global.database.scenes    -> Array[SceneEntry]
 #
-#   Global.database.get_table_by_name(name) -> Table
-#   Global.database.save_db()
-#   table.get_data_at_row_idx(row_id) -> [Cell, Cell, ...]
-#   table.edit_data(prop_id, row_id, value)
-#   table.m_rows_count
-#   table.get_data_by_prop_name_and_data(prop_name, value) -> Array
-#   table.get_dictionary_by_prop_name_and_data(prop_name, value) -> Array[Dict]
-#   cell.get_data() -> String
+# save() round-trips back to the same JSON format so game progress
+# (per-scene lock state) persists across runs.
 
-class Cell:
-	var _value
-	func _init(value):
-		_value = value
-	func get_data():
-		return _value
-
-class Table:
-	var name: String
-	var props: Array
-	var data: Array
-	var m_rows_count: int
-
-	func _init(table_dict: Dictionary):
-		name = table_dict["table_name"]
-		props = table_dict["props"]
-		data = table_dict["data"]
-		m_rows_count = data.size() / max(1, props.size())
-
-	func _col_count() -> int:
-		return props.size()
-
-	func _find_prop_idx(prop_name: String) -> int:
-		for i in range(props.size()):
-			if props[i]["name"] == prop_name:
-				return i
-		return -1
-
-	func get_data_at_row_idx(row_idx: int) -> Array:
-		var start = row_idx * _col_count()
-		var cells = []
-		for i in range(_col_count()):
-			cells.append(Cell.new(data[start + i]))
-		return cells
-
-	func edit_data(prop_id: int, row_id: int, value) -> void:
-		data[row_id * _col_count() + prop_id] = str(value)
-
-	func get_data_by_prop_name_and_data(prop_name: String, value) -> Array:
-		var prop_idx = _find_prop_idx(prop_name)
-		var matches = []
-		if prop_idx == -1:
-			return matches
-		for row in range(m_rows_count):
-			if data[row * _col_count() + prop_idx] == str(value):
-				matches.append(row)
-		return matches
-
-	func get_dictionary_by_prop_name_and_data(prop_name: String, value) -> Array:
-		var prop_idx = _find_prop_idx(prop_name)
-		var results = []
-		if prop_idx == -1:
-			return results
-		for row in range(m_rows_count):
-			if data[row * _col_count() + prop_idx] == str(value):
-				var d = {}
-				for i in range(_col_count()):
-					d[props[i]["name"]] = data[row * _col_count() + i]
-				results.append(d)
-		return results
-
-	func to_dict() -> Dictionary:
-		return {
-			"table_name": name,
-			"props": props,
-			"data": data,
-		}
-
-class DB:
-	var version: String
-	var db_name: String
-	var tables: Dictionary = {}
+class DB extends RefCounted:
+	var settings: SettingsData
+	var levels: Array[LevelEntry] = []
+	var scenes: Array[SceneEntry] = []
 	var _path: String
 
-	func _init(path: String):
+	const _SETTINGS_PROPS := [
+		{"name": "langue", "type": "1", "auto_increment": "0"},
+		{"name": "gyroscope", "type": "0", "auto_increment": "0"},
+		{"name": "ambient_sound", "type": "0", "auto_increment": "0"},
+		{"name": "resolution", "type": "3", "auto_increment": "0"},
+		{"name": "fullscreen", "type": "0", "auto_increment": "0"},
+		{"name": "version", "type": "0", "auto_increment": "0"},
+	]
+	const _LEVELS_PROPS := [
+		{"name": "name", "type": "3", "auto_increment": "0"},
+		{"name": "thumb", "type": "4", "auto_increment": "0"},
+	]
+	const _SCENES_PROPS := [
+		{"name": "lock", "type": "0", "auto_increment": "0"},
+		{"name": "label", "type": "3", "auto_increment": "0"},
+		{"name": "key", "type": "3", "auto_increment": "0"},
+		{"name": "level", "type": "table", "table_name": "levels", "auto_increment": "0"},
+		{"name": "mesh", "type": "3", "auto_increment": "0"},
+		{"name": "label_counter", "type": "1", "auto_increment": "0"},
+		{"name": "counter", "type": "1", "auto_increment": "0"},
+	]
+
+	func _init(path: String) -> void:
 		_path = path
-		var f = FileAccess.open(path, FileAccess.READ)
+		var f := FileAccess.open(path, FileAccess.READ)
 		if f == null:
 			push_error("[Database] Cannot open " + path)
 			return
-		var raw = f.get_as_text()
+		var doc = JSON.parse_string(f.get_as_text())
 		f.close()
-		var doc = JSON.parse_string(raw)
-		if doc == null:
+		if not (doc is Dictionary):
 			push_error("[Database] Invalid JSON in " + path)
 			return
-		version = doc.get("GDDB_ver", "")
-		db_name = doc.get("db_name", "")
-		for t in doc.get("tables", []):
-			var table = Table.new(t)
-			tables[table.name] = table
+		for table in doc.get("tables", []):
+			match table.get("table_name", ""):
+				"settings": settings = _load_settings(table.get("data", []))
+				"levels": levels = _load_levels(table.get("data", []))
+				"scenes": scenes = _load_scenes(table.get("data", []))
 
-	func get_table_by_name(name: String):
-		return tables.get(name)
+	func _load_settings(data: Array) -> SettingsData:
+		var s := SettingsData.new()
+		if data.size() >= 6:
+			s.langue = int(data[0])
+			s.gyroscope = bool(int(data[1]))
+			s.ambient_sound = bool(int(data[2]))
+			s.resolution = str(data[3])
+			s.fullscreen = bool(int(data[4]))
+			s.version = str(data[5])
+		return s
 
-	func save_db() -> void:
-		var doc = {
-			"GDDB_ver": version,
-			"db_name": db_name,
-			"tables": [],
+	func _load_levels(data: Array) -> Array[LevelEntry]:
+		var result: Array[LevelEntry] = []
+		const W := 2
+		for i in range(data.size() / W):
+			var l := LevelEntry.new()
+			l.index = i
+			l.name = str(data[i * W + 0])
+			l.thumb = str(data[i * W + 1])
+			result.append(l)
+		return result
+
+	func _load_scenes(data: Array) -> Array[SceneEntry]:
+		var result: Array[SceneEntry] = []
+		const W := 7
+		for i in range(data.size() / W):
+			var s := SceneEntry.new()
+			s.lock = bool(int(data[i * W + 0]))
+			s.label = str(data[i * W + 1])
+			s.key = str(data[i * W + 2])
+			s.level = int(data[i * W + 3])
+			s.mesh = str(data[i * W + 4])
+			s.label_counter = str(data[i * W + 5])
+			s.counter = int(data[i * W + 6])
+			result.append(s)
+		return result
+
+	func scenes_for_level(level_idx: int) -> Array[SceneEntry]:
+		var result: Array[SceneEntry] = []
+		for s in scenes:
+			if s.level == level_idx:
+				result.append(s)
+		return result
+
+	func level_by_index(idx: int) -> LevelEntry:
+		for l in levels:
+			if l.index == idx:
+				return l
+		return null
+
+	func save() -> void:
+		var doc := {
+			"GDDB_ver": "2.0",
+			"db_name": "ahog",
+			"tables": [
+				{"table_name": "settings", "props": _SETTINGS_PROPS, "data": _dump_settings()},
+				{"table_name": "levels", "props": _LEVELS_PROPS, "data": _dump_levels()},
+				{"table_name": "scenes", "props": _SCENES_PROPS, "data": _dump_scenes()},
+			],
 		}
-		for tname in tables:
-			doc["tables"].append(tables[tname].to_dict())
-		var f = FileAccess.open(_path, FileAccess.WRITE)
+		var f := FileAccess.open(_path, FileAccess.WRITE)
 		if f == null:
 			push_error("[Database] Cannot write " + _path)
 			return
 		f.store_string(JSON.stringify(doc))
 		f.close()
 
+	func _dump_settings() -> Array:
+		return [
+			str(settings.langue),
+			str(int(settings.gyroscope)),
+			str(int(settings.ambient_sound)),
+			settings.resolution,
+			str(int(settings.fullscreen)),
+			settings.version,
+		]
+
+	func _dump_levels() -> Array:
+		var out: Array = []
+		for l in levels:
+			out.append_array([l.name, l.thumb])
+		return out
+
+	func _dump_scenes() -> Array:
+		var out: Array = []
+		for s in scenes:
+			out.append_array([
+				str(int(s.lock)),
+				s.label,
+				s.key,
+				str(s.level),
+				s.mesh,
+				s.label_counter,
+				str(s.counter),
+			])
+		return out
+
 func initialize() -> DB:
 	return DB.new(save_database_in())
 
@@ -141,8 +168,8 @@ func normal_path() -> String:
 func copy_database() -> void:
 	if FileAccess.file_exists(android_path()):
 		return
-	var src = FileAccess.open(normal_path(), FileAccess.READ)
-	var dst = FileAccess.open(android_path(), FileAccess.WRITE)
+	var src := FileAccess.open(normal_path(), FileAccess.READ)
+	var dst := FileAccess.open(android_path(), FileAccess.WRITE)
 	dst.store_string(src.get_as_text())
 	dst.close()
 	src.close()

scripts/Global.gd

@@ -1,77 +1,70 @@
 extends Control
 
-@onready var current_scene = null
-@onready var current_scene_int = null
-@onready var wait_frames = 1
-@onready var database = null
-@onready var loaded = false
-@onready var animation = Loading.get_node("AnimLoading")
+# Application root: async scene loading + reference to the loaded Database.
 
+@onready var animation: AnimationPlayer = Loading.get_node("AnimLoading")
+
+var current_scene: Node = null
+var current_scene_int: int = -1
+var wait_frames: int = 1
+var database: RefCounted = null
+var loaded: bool = false
 var _loading_path: String = ""
 
-func _ready():
+func _ready() -> void:
 	database = load("res://scripts/Database.gd").new().initialize()
-
 	_initialize_current_scene()
 	_initialize_loading_scene()
 
-func _initialize_loading_scene():
+func _initialize_loading_scene() -> void:
 	animation.animation_started.connect(Event._loading_is_started)
 	animation.animation_finished.connect(Event._loading_is_finished)
 
-func goto_scene(path):
-	print("[global#goto_scene] : load scene " + str(path))
-	var err = ResourceLoader.load_threaded_request(path)
+func goto_scene(path: String) -> void:
+	var err := ResourceLoader.load_threaded_request(path)
 	if err != OK:
-		print("Error loading ....")
+		push_error("[Global] failed to start threaded load for " + path)
 		return
-
 	_loading_path = path
 	Loading.show()
 	animation.play("BorderAnim")
-
 	set_process(true)
 	current_scene.queue_free()
 	wait_frames = 1
 	Loading.get_node("LoadingBare/VBoxContainer/HBoxContainer/ProgressBar").set_max(1.0)
 
-func _process(_delta):
+func _process(_delta: float) -> void:
 	if _loading_path == "":
 		set_process(false)
 		return
-
 	if wait_frames > 0:
 		wait_frames -= 1
-
 	if not loaded:
 		return
-
-	var progress := []
-	var status = ResourceLoader.load_threaded_get_status(_loading_path, progress)
+	var progress: Array = []
+	var status := ResourceLoader.load_threaded_get_status(_loading_path, progress)
 	match status:
 		ResourceLoader.THREAD_LOAD_IN_PROGRESS:
 			_update_progress(progress[0] if progress.size() > 0 else 0.0)
 		ResourceLoader.THREAD_LOAD_LOADED:
 			_set_new_scene()
 		ResourceLoader.THREAD_LOAD_FAILED, ResourceLoader.THREAD_LOAD_INVALID_RESOURCE:
-			print("Error loading ....")
+			push_error("[Global] failed to load " + _loading_path)
 			_loading_path = ""
 
 ## PRIVATE
-func _initialize_current_scene():
-	print("[global#_initialize_current_scene]")
-	var root = get_tree().get_root()
+func _initialize_current_scene() -> void:
+	var root := get_tree().get_root()
 	current_scene = root.get_child(root.get_child_count() - 1)
-
 	if current_scene.name != "Main":
-		get_node("/root/Loading").hide()
+		Loading.hide()
 
-func _update_progress(value: float):
+func _update_progress(value: float) -> void:
 	Loading.visible = true
 	Loading.get_node("LoadingBare/VBoxContainer/HBoxContainer/ProgressBar").set_value(value)
 
-func _set_new_scene():
-	var resource = ResourceLoader.load_threaded_get(_loading_path)
+func _set_new_scene() -> void:
+	var resource: PackedScene = ResourceLoader.load_threaded_get(_loading_path)
 	_loading_path = ""
 	current_scene = resource.instantiate()
 	get_node("/root").add_child(current_scene)

scripts/Setting.gd

@@ -1,66 +1,69 @@
 extends Node
 
-@onready var setting = load("res://db/MSetting.gd").new()
+# Reads / writes the SettingsData held by Global.database. Applies locale,
+# resolution, and fullscreen state on startup and on any setter call.
 
-func _ready():
+func _ready() -> void:
 	apply_language(translate_int_to_locale(get_setting_language()))
 	apply_resolution()
 	apply_fullscreen()
 
-func apply_language(local):
-	TranslationServer.set_locale(local)
+func apply_language(locale: String) -> void:
+	TranslationServer.set_locale(locale)
 
-func translate_int_to_locale(id):
-	var lang = "en"
+func translate_int_to_locale(id: int) -> String:
+	match id:
+		0: return "en"
+		1: return "fr"
+	return "en"
 
-	if id == 0:
-		lang = "en"
+func apply_resolution() -> void:
+	var res := get_setting_resolution()
+	get_window().content_scale_size = Vector2i(int(res[0]), int(res[1]))
 
-	if id == 1:
-		lang = "fr"
+func apply_fullscreen() -> void:
+	get_window().mode = Window.MODE_EXCLUSIVE_FULLSCREEN if get_setting_fullscreen() else Window.MODE_WINDOWED
 
-	return lang
+func _data() -> SettingsData:
+	return Global.database.settings
 
-func apply_resolution():
-	var res = get_setting_resolution()
-	var screen_size = Vector2i(int(res[0]), int(res[1]))
-	get_window().content_scale_size = screen_size
+func get_setting_language() -> int:
+	return _data().langue
 
-func apply_fullscreen():
-	get_window().mode = Window.MODE_EXCLUSIVE_FULLSCREEN if (get_setting_fullscreen()) else Window.MODE_WINDOWED
-
-func get_setting_language():
-	return setting.get_langue()
-
-func set_setting_language(value):
-	setting.set_langue(value)
+func set_setting_language(value: int) -> void:
+	_data().langue = value
+	Global.database.save()
 	apply_language(translate_int_to_locale(value))
 
-func get_setting_gyrosocpe():
-	return setting.get_gyroscope()
+func get_setting_gyrosocpe() -> bool:
+	return _data().gyroscope
 
-func set_setting_gyroscope(value):
-	setting.set_gyroscope(value)
+func set_setting_gyroscope(value: bool) -> void:
+	_data().gyroscope = value
+	Global.database.save()
 
-func get_setting_ambient_sound():
-	return setting.get_ambient_sound()
+func get_setting_ambient_sound() -> bool:
+	return _data().ambient_sound
 
-func set_setting_ambient_sound(value):
-	setting.set_ambient_sound(value)
+func set_setting_ambient_sound(value: bool) -> void:
+	_data().ambient_sound = value
+	Global.database.save()
 
-func get_setting_resolution():
-	return setting.get_resolution()
+func get_setting_resolution() -> PackedStringArray:
+	return _data().resolution_split()
 
-func set_setting_resolution(value):
-	setting.set_resolution(value)
+func set_setting_resolution(value: String) -> void:
+	_data().resolution = value
+	Global.database.save()
 	apply_resolution()
 
-func get_setting_fullscreen():
-	return setting.get_fullscreen()
+func get_setting_fullscreen() -> bool:
+	return _data().fullscreen
 
-func set_setting_fullscreen(value):
-	setting.set_fullscreen(value)
+func set_setting_fullscreen(value: bool) -> void:
+	_data().fullscreen = value
+	Global.database.save()
 	apply_fullscreen()
 
-func get_setting_version():
-	return setting.get_version()
+func get_setting_version() -> String:
+	return "v" + _data().version

scripts/event.gd

@@ -22,12 +22,12 @@ static func _on_home_pressed() -> void:
 	Global.current_scene_int = 1
 	Global.goto_scene("res://scenes/levels/home/Home.tscn")
 
-static func _on_reset_level(level, node: String, index: int, parent) -> void:
+static func _on_reset_level(level: LevelEntry, node: String, index: int, parent) -> void:
 	Global.current_scene_int = index
 	level.reset()
-	parent.configure_reset(level, node, index, true)
+	parent.configure_reset(level, node, true)
 	parent.configure_counter(level, node)
-	Global.current_scene_int = null
+	Global.current_scene_int = -1
 
 static func _on_main_scene_pressed() -> void:
 	Global.goto_scene("res://scenes/Main.tscn")