wip: drop actionInputIcon in favor of bones's icon comp

addons/bones/actions/ActionInputIcon.tscn

@@ -4,7 +4,6 @@
 [ext_resource type="Script" path="res://addons/bones/actions/ActionInputIcon.gd" id="1_ui3le"]
 
 [node name="ActionInputIcon" type="TextureRect"]
-visible = false
 custom_minimum_size = Vector2(30, 0)
 offset_right = 30.0
 offset_bottom = 48.0

src/Store.gd

@@ -3,7 +3,7 @@ extends Node
 
 ## _ready ###########################################
 
-func _enter_tree():
+func _enter_tree() -> void:
 	load_game()
 
 ## data store ###########################################
@@ -12,25 +12,25 @@ var state: GameState
 
 var events: Array[Event] = []
 
-func save_game():
-	events.map(func(ev):
+func save_game() -> void:
+	events.map(func(ev: Event) -> void:
 		if ev == null: Log.warn("Cannot save null event!", ev)
 		)
 	SaveGame.save_game(get_tree(), {
-		events=events.filter(func(ev): return ev != null)\
+		events=events.filter(func(ev: Event) -> bool: return ev != null)\
 		.map(Pandora.serialize),
 		})
 
 # validation and basic recovery from crashes on loaded data?
 # i.e. missing puzzle_sets, at least set the initial ones and get to playable state
-func load_game():
-	var data = SaveGame.load_game(get_tree())
+func load_game() -> void:
+	var data: Dictionary = SaveGame.load_game(get_tree())
 
 	if not "events" in data or len(data.events) == 0:
 		events = initial_events()
 	else:
-		events.assign(data.events\
-			.filter(func(ev): return ev != null)\
+		events.assign((data.events as Array)\
+			.filter(func(ev: Event) -> bool: return ev != null)\
 			# TODO handle crashes when events can't deserialize
 			.map(Pandora.deserialize))
 
@@ -40,7 +40,7 @@ func load_game():
 		events=len(events), puzzle_sets=len(state.puzzle_sets), themes=len(state.themes)
 		})
 
-func reset_game_data():
+func reset_game_data() -> void:
 	SaveGame.delete_save()
 	load_game()
 
@@ -54,7 +54,7 @@ func initial_events() -> Array[Event]:
 func get_puzzle_sets() -> Array[PuzzleSet]:
 	return state.puzzle_sets
 
-func find_puzzle_set(ps: PuzzleSet):
+func find_puzzle_set(ps: PuzzleSet) -> PuzzleSet:
 	return state.find_puzzle_set(ps)
 
 func get_themes() -> Array[PuzzleTheme]:
@@ -63,20 +63,20 @@ func get_themes() -> Array[PuzzleTheme]:
 func get_events() -> Array[Event]:
 	return events
 
-func find_events(filter_fn) -> Array[Event]:
+func find_events(filter_fn: Callable) -> Array[Event]:
 	return events.filter(filter_fn)
 
-func find_event(filter_fn) -> Event:
-	var evs = find_events(filter_fn)
+func find_event(filter_fn: Callable) -> Event:
+	var evs: Array = find_events(filter_fn)
 	if len(evs) > 0:
 		return evs[0]
 	else:
 		return null
 
 ## events ###########################################
 
-func complete_puzzle_set(puz: PuzzleSet):
-	var event = find_event(func(ev): return PuzzleSetCompleted.is_matching_event(ev, puz))
+func complete_puzzle_set(puz: PuzzleSet) -> void:
+	var event: PuzzleSetCompleted = find_event(func(ev: Event) -> bool: return PuzzleSetCompleted.is_matching_event(ev, puz))
 	if event:
 		event.inc_count()
 	elif not event:
@@ -85,29 +85,30 @@ func complete_puzzle_set(puz: PuzzleSet):
 		events.append(event)
 	save_game()
 
-func complete_puzzle_index(puz: PuzzleSet, idx: int):
-	var event = find_event(func(ev): return PuzzleCompleted.is_matching_event(ev, puz, idx))
+func complete_puzzle_index(puz: PuzzleSet, idx: int) -> void:
+	var event: PuzzleCompleted = find_event(func(ev: Event) -> bool: return PuzzleCompleted.is_matching_event(ev, puz, idx))
 	if event:
 		event.inc_count()
 	elif not event:
 		event = PuzzleCompleted.new_event(puz, idx)
 		state.apply_event(event)
 		events.append(event)
 
-	var skip_event = find_event(func(ev):
-		return PuzzleSkipped.is_matching_event(ev, puz, idx) and ev.is_active())
+	var skip_event: Event = find_event(func(ev: Event) -> bool:
+		return PuzzleSkipped.is_matching_event(ev, puz, idx) and (ev as PuzzleSkipped).is_active())
 	if skip_event:
-		skip_event.mark_inactive()
+		(skip_event as PuzzleSkipped).mark_inactive()
 		# NOTE the in-place (passed) puzzle set is not updated
 		state.apply_event(skip_event)
 
-	var p = state.find_puzzle_set(event.get_puzzle_set())
+	@warning_ignore("unsafe_method_access")
+	var p: PuzzleSet = state.find_puzzle_set(event.get_puzzle_set() as PuzzleSet)
 	p.attach_game_def_stats()
 
 	save_game()
 
-func skip_puzzle(puz: PuzzleSet, idx: int):
-	var event = find_event(func(ev): return PuzzleSkipped.is_matching_event(ev, puz, idx))
+func skip_puzzle(puz: PuzzleSet, idx: int) -> void:
+	var event: PuzzleSkipped = find_event(func(ev: Event) -> bool: return PuzzleSkipped.is_matching_event(ev, puz, idx))
 	if event:
 		event.inc_count()
 	elif not event:
@@ -120,8 +121,8 @@ func skip_puzzle(puz: PuzzleSet, idx: int):
 
 	save_game()
 
-func unlock_puzzle_set(puz: PuzzleSet):
-	var event = find_event(func(ev): return PuzzleSetUnlocked.is_matching_event(ev, puz))
+func unlock_puzzle_set(puz: PuzzleSet) -> void:
+	var event: Event = find_event(func(ev: Event) -> bool: return PuzzleSetUnlocked.is_matching_event(ev, puz))
 	if event:
 		event.inc_count()
 	elif not event:
@@ -133,17 +134,17 @@ func unlock_puzzle_set(puz: PuzzleSet):
 	save_game()
 
 # Deprecated
-func unlock_next_puzzle_set(puz: PuzzleSet):
-	var next = puz.get_next_puzzle_set()
+func unlock_next_puzzle_set(puz: PuzzleSet) -> void:
+	var next: PuzzleSet = puz.get_next_puzzle_set()
 	if next:
 		unlock_puzzle_set(next)
 	else:
 		Log.warn("No next puzzle to unlock!", puz)
 
-func unlock_all_puzzle_sets():
+func unlock_all_puzzle_sets() -> void:
 	Log.warn("Unlocking all puzzle sets!")
-	for ps in state.puzzle_sets:
-		var event = find_event(func(ev): return PuzzleSetUnlocked.is_matching_event(ev, ps))
+	for ps: PuzzleSet in state.puzzle_sets:
+		var event: PuzzleSetUnlocked = find_event(func(ev: Event) -> bool: return PuzzleSetUnlocked.is_matching_event(ev, ps))
 		if event:
 			continue
 		event = PuzzleSetUnlocked.new_event(ps)

src/events/PuzzleCompleted.gd

@@ -29,7 +29,7 @@ static func new_event(puzzle_set: PuzzleSet, puzzle_idx: int) -> PuzzleCompleted
 		})
 	return event
 
-static func is_matching_event(event: PuzzleCompleted, puzzle_set: PuzzleSet, idx: int) -> bool:
+static func is_matching_event(event: Event, puzzle_set: PuzzleSet, idx: int) -> bool:
 	if not event is PuzzleCompleted:
 		return false
 	return (event as PuzzleCompleted).get_puzzle_set_id() == puzzle_set.get_entity_id() and \

src/hud/HUD.gd

@@ -3,19 +3,20 @@ class_name HUD
 
 ## vars ########################################################
 
-@onready var puzzle_num_label = $%LevelNum
-@onready var puzzle_message_label = $%LevelMessage
-@onready var dots_remaining_label = $%DotsRemaining
+@onready var puzzle_num_label: RichTextLabel = $%LevelNum
+@onready var puzzle_message_label: RichTextLabel = $%LevelMessage
+@onready var dots_remaining_label: RichTextLabel = $%DotsRemaining
 
-@onready var undo_control_hint = $%UndoControlHint
-@onready var reset_control_hint = $%ResetControlHint
-@onready var undo_label = $%UndoLabel
-@onready var reset_label = $%ResetLabel
-@onready var undo_input_icon = $%UndoInputIcon
-@onready var reset_input_icon = $%ResetInputIcon
+@onready var undo_control_hint: BoxContainer = $%UndoControlHint
+@onready var reset_control_hint: BoxContainer = $%ResetControlHint
+@onready var undo_label: RichTextLabel = $%UndoLabel
+@onready var reset_label: RichTextLabel = $%ResetLabel
 
-@onready var undo_button = $%UndoButton
-@onready var reset_button = $%ResetButton
+@onready var undo_input_icon: ActionInputIcon = $%UndoInputIcon
+@onready var reset_input_icon: ActionInputIcon = $%ResetInputIcon
+
+@onready var undo_button: Button = $%UndoButton
+@onready var reset_button: Button = $%ResetButton
 
 signal undo_pressed
 signal reset_pressed
@@ -24,25 +25,25 @@ var puzzle_def: PuzzleDef
 
 ## ready ########################################################
 
-func _ready():
+func _ready() -> void:
 	set_control_icons()
-	InputHelper.device_changed.connect(func(_device, _di): set_control_icons())
-	InputHelper.joypad_changed.connect(func(_di, _connected): set_control_icons())
-	InputHelper.keyboard_input_changed.connect(func(_action, _event): set_control_icons())
-	InputHelper.joypad_input_changed.connect(func(_action, _event): set_control_icons())
+	InputHelper.device_changed.connect(func(_device: String, _di: int) -> void: set_control_icons())
+	InputHelper.joypad_changed.connect(func(_di: int, _connected: bool) -> void: set_control_icons())
+	InputHelper.keyboard_input_changed.connect(func(_action: String, _event: InputEvent) -> void: set_control_icons())
+	InputHelper.joypad_input_changed.connect(func(_action: String, _event: InputEvent) -> void: set_control_icons())
 
-	reset_button.pressed.connect(func(): reset_pressed.emit())
-	undo_button.pressed.connect(func(): undo_pressed.emit())
+	reset_button.pressed.connect(func() -> void: reset_pressed.emit())
+	undo_button.pressed.connect(func() -> void: undo_pressed.emit())
 
-func set_control_icons():
+func set_control_icons() -> void:
 	undo_input_icon.set_icon_for_action("ui_undo")
 	reset_input_icon.set_icon_for_action("restart")
 
 ## unhandled_input ########################################################
 
-func _unhandled_input(event):
-	var is_restart_held = Trolls.is_restart_held(event)
-	var is_restart_released = Trolls.is_restart_released(event)
+func _unhandled_input(event: InputEvent) -> void:
+	var is_restart_held: bool = Trolls.is_restart_held(event)
+	var is_restart_released: bool = Trolls.is_restart_released(event)
 
 	if is_restart_held:
 		show_resetting()
@@ -51,9 +52,9 @@ func _unhandled_input(event):
 
 ## update ########################################################
 
-var last_puzzle_update
+var last_puzzle_update: Dictionary
 
-func update_state(data):
+func update_state(data: Dictionary) -> void:
 	last_puzzle_update = data
 
 	puzzle_def = data.puzzle_def
@@ -63,9 +64,9 @@ func update_state(data):
 
 ## puzzle number ########################################################
 
-func update_puzzle_number(entry):
+func update_puzzle_number(entry: Dictionary) -> void:
 	if "puzzles_remaining" in entry:
-		var rem = entry.puzzles_remaining
+		var rem: int = entry.puzzles_remaining
 		if rem == 0:
 			puzzle_num_label.text = "[center]Puzzle set complete![/center]"
 		elif rem == 1:
@@ -75,50 +76,50 @@ func update_puzzle_number(entry):
 
 ## message ########################################################
 
-func update_puzzle_message():
+func update_puzzle_message() -> void:
 	if puzzle_def.get_message():
 		puzzle_message_label.text = "[center]%s[/center]" % puzzle_def.get_message()
 
 ## dots remaining ########################################################
 
-func update_dots_remaining(entry):
+func update_dots_remaining(entry: Dictionary) -> void:
 	if "dots_total" in entry:
 		dots_remaining_label.text = "[center]%s dots left[/center]" % entry.dots_remaining
 
 ## controls ########################################################
 
-func controls():
-	var cts = []
+func controls() -> Array:
+	var cts: Array = []
 	if not resetting:
 		cts.append(reset_control_hint)
 	if not undoing:
 		cts.append(undo_control_hint)
 	return cts
 
-var fade_controls_tween
-func fade_controls():
+var fade_controls_tween: Tween
+func fade_controls() -> void:
 	if fade_controls_tween != null and fade_controls_tween.is_running():
 		return
 	fade_controls_tween = create_tween()
 	# wait a bit before fading
 	fade_controls_tween.tween_interval(0.8)
-	controls().map(func(c):
+	controls().map(func(c: CanvasItem) -> void:
 		fade_controls_tween.parallel().tween_property(c, "modulate:a", 0.5, 0.8))
 
-var show_controls_tween
-func show_controls(force=false):
+var show_controls_tween: Tween
+func show_controls(force: bool = false) -> void:
 	Log.pr("showing controls (force: ", force, ")")
 	if show_controls_tween != null and show_controls_tween.is_running():
 		show_controls_tween.kill()
 		if not force:
 			return
 	show_controls_tween = create_tween()
-	controls().map(func(c):
+	controls().map(func(c: CanvasItem) -> void:
 		show_controls_tween.parallel().tween_property(c, "modulate:a", 1.0, 0.6))
 
 # could probably just use a timer, but meh
-var controls_tween
-func restart_fade_in_controls_tween():
+var controls_tween: Tween
+func restart_fade_in_controls_tween() -> void:
 	fade_controls()
 	if controls_tween != null:
 		controls_tween.kill()
@@ -127,10 +128,10 @@ func restart_fade_in_controls_tween():
 
 ## undoing ########################################################
 
-var undoing
-var undo_tween
-var undo_t = 0.3
-func animate_undo():
+var undoing: bool
+var undo_tween: Tween
+var undo_t: float = 0.3
+func animate_undo() -> void:
 	undoing = true
 
 	undo_control_hint.set_pivot_offset(undo_control_hint.size/2)
@@ -142,14 +143,14 @@ func animate_undo():
 	undo_tween.tween_property(undo_control_hint, "modulate:a", 1.0, undo_t/4)
 	undo_tween.parallel().tween_property(undo_control_hint, "scale", Vector2.ONE*1.4, undo_t/2)
 	undo_tween.tween_property(undo_control_hint, "scale", Vector2.ONE, undo_t/2)
-	undo_tween.tween_callback(func(): undoing = false)
+	undo_tween.tween_callback(func() -> void: undoing = false)
 
 ## restarting ########################################################
 
-var resetting
-var reset_tween
-func show_resetting():
-	var hold_t = DHData.reset_hold_t
+var resetting: bool
+var reset_tween: Tween
+func show_resetting() -> void:
+	var hold_t: float = DHData.reset_hold_t
 	resetting = true
 	reset_label.text = "Hold..."
 
@@ -163,7 +164,7 @@ func show_resetting():
 	# presumably we're back at the beginning
 	reset_tween.tween_callback(hide_resetting)
 
-func hide_resetting():
+func hide_resetting() -> void:
 	resetting = false
 	if reset_tween != null:
 		reset_tween.kill()