fix: static type fixes - tests passing again!

Author: russmatney

plug.gd

@@ -1,6 +1,6 @@
 extends "res://addons/gd-plug/plug.gd"
 
-func _plugging():
+func _plugging() -> void:
 	plug("MikeSchulze/gdUnit4", {exclude=["addons/gdUnit4/test"]})
 	plug("bitbrain/pandora", {include=["addons/pandora"]})
 	plug("nathanhoad/godot_input_helper", {include=["addons/input_helper"]})

src/parse/ParsedGame.gd

@@ -74,13 +74,15 @@ func parse_prelude(chunks: Array) -> Dictionary:
 
 func parse_objects(chunks: Array) -> Dictionary:
 	var objs := {}
-	for lines: Array[String] in chunks:
+	for lines: Array in chunks:
 		var obj := {}
-		var nm_parts := lines[0].split(" ")
+		var line: String = lines[0]
+		var nm_parts := line.split(" ")
 		obj.name = nm_parts[0]
 		if nm_parts.size() > 1:
 			obj.symbol = nm_parts[1]
-		obj.colors = Array(lines[1].split(" "))
+		var line2: String = lines[1]
+		obj.colors = Array(line2.split(" "))
 		if lines.size() > 2:
 			lines.remove_at(0)
 			lines.remove_at(0)

src/parse/Puzz.gd

@@ -12,7 +12,7 @@ static func parse_game_def(path: Variant, opts: Dictionary = {}) -> GameDef:
 		contents = file.get_as_text()
 
 	var parsed: Dictionary = ParsedGame.new().parse(contents)
-	return GameDef.new(path as String, parsed)
+	return GameDef.new(path, parsed)
 
 # helpful for supporting some tests
 static func parse_puzzle_def(lines: Array) -> PuzzleDef:

src/puzzle/GameDef.gd

@@ -12,8 +12,8 @@ var path: String
 
 ## init ########################################3333
 
-func _init(_path: String, parsed: Dictionary) -> void:
-	if _path:
+func _init(_path: Variant, parsed: Dictionary) -> void:
+	if _path != null:
 		path = _path
 	raw = parsed
 	legend = parsed.legend

src/puzzle/PuzzleScene.gd

@@ -17,7 +17,7 @@ static var fallback_puzzle_scene: String = "res://src/puzzle/PuzzleScene.tscn"
 #
 # This func could live on the DotHopGame script, but a function like this is useful
 # for testing just the game logic (without loading a full DotHopGame)
-static func build_puzzle_node(opts: Dictionary) -> Node2D:
+static func build_puzzle_node(opts: Dictionary) -> DotHopPuzzle:
 	# parse the puzzle script game, set game_def
 	var _game_def: GameDef = opts.get("game_def")
 	if not _game_def and opts.get("game_def_path"):
@@ -47,10 +47,10 @@ static func build_puzzle_node(opts: Dictionary) -> Node2D:
 	var _theme: PuzzleTheme = opts.get("puzzle_theme")
 	var _theme_data: PuzzleThemeData = opts.get("puzzle_theme_data")
 	var scene: PackedScene = opts.get("puzzle_scene", _theme_data.puzzle_scene if _theme_data else null)
-	if scene == null:
+	if scene == null and opts.get("puzzle_scene_path") != null:
 		# TODO Drop support for this unless we use it (maybe in tests?)
 		scene = load(str(opts.get("puzzle_scene_path")))
-	elif scene == null:
+	if scene == null:
 		scene = load(fallback_puzzle_scene)
 
 	var node: DotHopPuzzle = scene.instantiate()
@@ -574,7 +574,9 @@ func move_player_to_cell(player: Dictionary, cell: Dictionary) -> Signal:
 	@warning_ignore("unsafe_method_access")
 	if player.node.has_method("move_to_coord"):
 		@warning_ignore("unsafe_method_access")
-		move_finished_sig = player.node.move_to_coord(cell.coord)
+		var res: Variant = player.node.move_to_coord(cell.coord)
+		if res != null:
+			move_finished_sig = res
 	else:
 		player.node.position = cell.coord * square_size
 

test/dotHop/puzzle_analysis_test.gd

@@ -2,15 +2,16 @@ extends GdUnitTestSuite
 class_name PuzzleAnalysisTest
 
 
-func build_puzzle(puzzle):
-	var puzzle_node = DotHopPuzzle.build_puzzle_node({puzzle=puzzle,
+func build_puzzle(puzzle: Array) -> DotHopPuzzle:
+	var puzzle_node := DotHopPuzzle.build_puzzle_node({puzzle=puzzle,
 		game_def_path="res://src/puzzles/dothop.txt"})
 	puzzle_node.init_game_state()
 	return puzzle_node
 
 ## test the solver ##################################################
 
-func test_puzzle_solver_basic(puzz, solvable, test_parameters=[
+@warning_ignore("unused_parameter")
+func test_puzzle_solver_basic(puzz: Array, solvable: bool, test_parameters: Array = [
 		[["xot"], true],
 		[[
 			"x.",
@@ -31,15 +32,16 @@ func test_puzzle_solver_basic(puzz, solvable, test_parameters=[
 			"ox.o.ot",
 			"...o.o.",
 			], true],
-	]):
-	var puzzle = build_puzzle(puzz)
-	var result = PuzzleAnalysis.new(puzzle).analyze()
+	]) -> void:
+	var puzzle := build_puzzle(puzz)
+	var result := PuzzleAnalysis.new(puzzle).analyze()
 	assert_bool(result.solvable).is_equal(solvable)
 
 	puzzle.free()
 
 
-func test_puzzle_solver_analysis(puzz, expected_result, test_parameters=[
+@warning_ignore("unused_parameter")
+func test_puzzle_solver_analysis(puzz: Array, expected_result: Dictionary, test_parameters: Array = [
 		[["xot"], {
 			solvable=true,
 			path_count=1, winning_path_count=1, stuck_path_count=0,
@@ -78,36 +80,36 @@ func test_puzzle_solver_analysis(puzz, expected_result, test_parameters=[
 			solvable=true,
 			path_count=22, winning_path_count=2, stuck_path_count=20,
 			}],
-	]):
-	var puzzle = build_puzzle(puzz)
+	]) -> void:
+	var puzzle := build_puzzle(puzz)
 
-	var result = PuzzleAnalysis.new(puzzle).analyze()
+	var result := PuzzleAnalysis.new(puzzle).analyze()
 
-	for k in expected_result:
+	for k: String in expected_result:
 		assert_that(expected_result[k]).is_equal(result.get(k))
 
 	puzzle.free()
 
 ## test in-game puzzles ##################################################
 
-func test_all_puzzles_solvable():
-	var sets = Store.get_puzzle_sets()
+func test_all_puzzles_solvable() -> void:
+	var sets := Store.get_puzzle_sets()
 	assert_int(len(sets)).is_greater(3) # make sure we get some
 
 	for puzzle_set in sets:
-		var game_def = Puzz.parse_game_def(puzzle_set.get_puzzle_script_path())
-		var puzzle_count = len(game_def.puzzles)
+		var game_def := Puzz.parse_game_def(puzzle_set.get_puzzle_script_path())
+		var puzzle_count := len(game_def.puzzles)
 		assert_int(puzzle_count).is_greater(0)
 		for i in puzzle_count:
 			# requiring a node that is added to the scene to analyze is a damn shame here
 			# (can the analysis be run without the node's _ready()?
-			var puzz_node = DotHopPuzzle.build_puzzle_node({
+			var puzz_node := DotHopPuzzle.build_puzzle_node({
 				game_def=game_def,
 				puzzle_num=i,
 				})
 			puzz_node.init_game_state()
 
-			var solve = PuzzleAnalysis.new(puzz_node).analyze()
+			var solve := PuzzleAnalysis.new(puzz_node).analyze()
 			Log.pr(["Puzzle:", puzzle_set.get_display_name(), "num:", i,
 				"solvable?", solve.solvable,
 				"dot count", solve.dot_count,

test/store/store_test.gd

@@ -38,7 +38,7 @@ func test_initial_store_theme_data() -> void:
 	assert_that(len(themes)).is_equal(len(theme_ents))
 
 	# at least one theme unlocked
-	var unlocked := themes.filter(func(ent: PuzzleSet) -> bool: return ent.is_unlocked())
+	var unlocked := themes.filter(func(ent: PuzzleTheme) -> bool: return ent.is_unlocked())
 	assert_int(len(unlocked)).is_greater(0)
 
 #########################################################################