refactor: replace threads with coroutines

entities/game/card_template/scripts/ToggleCardVisibility.gd

@@ -34,8 +34,6 @@ var removal_planned: bool = false
 var animation_tween: Tween = null
 var _focus_tween: Tween = null
 
-var fix_image_thread: Thread
-
 var visibility: VisibilityEnum = VisibilityEnum.HIDDEN
 
 func _ready() -> void:

entities/game/memory_game/scripts/CardSpawner.gd

@@ -13,8 +13,7 @@ signal card_placing_done()
 #@export var place_offset: Vector2 = Vector2.ZERO
 @onready var _card_target_node: Node2D = get_node("%CardBoard/CardVisuals")
 
-var _load_thread: Thread = null
-var _place_thread: Thread = null
+var _field_size: Vector2i = Vector2i.ZERO
 var _current_deck: MemoryDeckResource
 
 func _ready() -> void:
@@ -28,22 +27,15 @@ func place_cards_from_deck(deck_to_use: MemoryDeckResource, card_separation: int
 	if multiplayer.is_server():
 		_rpc_announce_deck.rpc(deck_to_use.resource_path)
 
+	var loaded_cards: Array[CardTemplate] = await build_card_layout(deck_to_use, card_template, card_separation, field_offset)
 
-	_load_thread = Thread.new()
-	_load_thread.start(build_card_layout.bind(deck_to_use, card_template, card_separation, field_offset))
-
-	await field_constructed
+	field_constructed.emit(_field_size.x, _field_size.y)
 	process_mode = PROCESS_MODE_INHERIT
-
-	var cards: Array[CardTemplate] = _load_thread.wait_to_finish() as Array[CardTemplate]
-	_load_thread = null
-
-	_place_thread = Thread.new()
-	_place_thread.start(_add_cards_to_field_async.bind(cards, _card_target_node))
 
-	await card_placing_done
+	await _add_cards_to_field_async(loaded_cards, _card_target_node)
+	card_placing_done.emit()
 
-	for card: CardTemplate in cards:
+	for card: CardTemplate in loaded_cards:
 		card.visible = true
 	announce_card_field()
 	card_loading_done.emit()
@@ -52,12 +44,12 @@ func place_cards_from_deck(deck_to_use: MemoryDeckResource, card_separation: int
 func _add_cards_to_field_async(cards: Array[CardTemplate], target: Node2D) -> void:
 	for card: CardTemplate in cards:
 		card.visible = false
-		target.call_deferred("add_child", card)
+		target.add_child(card)
+
+		card_placed.emit(card)
 
-		call_deferred("emit_signal","card_placed", card)
 		for i: int in artificial_wait_time:
 			await get_tree().physics_frame
-	call_deferred("emit_signal","card_placing_done")
 
 func _calculate_field_size(cards_on_x: int, cards_on_y: int, separation: int) -> void:
 	if card_template == null:
@@ -103,7 +95,7 @@ func build_card_layout(deck_of_cards: MemoryDeckResource,
 
 	while row_count * column_count < card_pool.size():
 		column_count = column_count + 1
-	call_deferred("_calculate_field_size", column_count, row_count, card_separation)
+	_calculate_field_size(column_count, row_count, card_separation)
 	for y: int in row_count:
 		for x: int in column_count:
 			var card_template_node: CardTemplate = template.instantiate() as CardTemplate
@@ -123,7 +115,8 @@ func build_card_layout(deck_of_cards: MemoryDeckResource,
 
 			return_cards.append(card_template_node)
 			current_card = current_card + 1
-	call_deferred("emit_signal","field_constructed", column_count, row_count)
+	await get_tree().physics_frame
+	_field_size = Vector2i(column_count, row_count)
 	return return_cards
 
 func numbering_cards_from_pool(card_pool: Array[MemoryCardResource]) -> Array[MemoryCardResource]:

entities/ui/custom_deck_create/scripts/CreateCustomDeck.gd

@@ -14,7 +14,6 @@ var _current_deck: CustomDeckResource = null
 var _last_loaded_deck: Array[CustomDeckResource] = []
 var _name_is_valid: bool = false
 
-var _load_thread: Thread = null
 var _lazy_loader: CustomDeckLoader = null
 
 signal deck_updated(deck: CustomDeckResource)
@@ -27,19 +26,6 @@ func _get_loader() -> CustomDeckLoader:
 		_lazy_loader = CustomDeckLoader.new()
 	return _lazy_loader
 
-func _process(_delta: float) -> void:
-	if _load_thread == null or _load_thread.is_alive():
-		return
-
-	var data: Variant = _load_thread.wait_to_finish()
-	_load_thread = null
-	deck_loaded.emit()
-	_sync_name_valid()
-	if data != null and data is Array[CustomDeckResource]:
-		set_deck(find_deck(data))
-		_last_loaded_deck = data
-		currently_editing.emit()
-
 
 func _reset() -> void:
 	_last_loaded_deck = []
@@ -87,15 +73,19 @@ func set_deck(deck: CustomDeckResource) -> void:
 		deck_updated.emit(_current_deck)
 
 func load_existing_deck(path: String) -> void:
-	if _load_thread != null and _load_thread.is_active():
-		return
 	_last_loaded_deck = []
 	if path == "":
 		return
 	var loader: CustomDeckLoader = _get_loader()
 	load_deck.emit()
-	_load_thread = loader.load_editable_deck_async(path)
+	var data: Array[CustomDeckResource] = await loader.load_editable_deck(path)
+	deck_loaded.emit()
 
+	_sync_name_valid()
+	if data != null:
+		set_deck(find_deck(data))
+		_last_loaded_deck = data
+		currently_editing.emit()
 
 func find_deck(deck_data: Array[CustomDeckResource]) -> CustomDeckResource:
 	for data: CustomDeckResource in deck_data:

entities/ui/deck_viewer/scenes/DeckViewer.tscn

@@ -208,6 +208,7 @@ offset_bottom = 40.0
 [connection signal="toggled" from="VBoxContainer/MarginContainer/PanelContainer/Deck Controls/Show Built In" to="VBoxContainer/MarginContainer2/PanelContainer2/HSplitContainer/Decks/DeckContainer" method="show_only_built_in"]
 [connection signal="toggled" from="VBoxContainer/MarginContainer/PanelContainer/Deck Controls/Show Custom" to="VBoxContainer/MarginContainer2/PanelContainer2/HSplitContainer/Decks/DeckContainer" method="show_only_custom"]
 [connection signal="data_reloaded" from="VBoxContainer/MarginContainer2/PanelContainer2/HSplitContainer/Decks/DeckContainer" to="VBoxContainer/MarginContainer/PanelContainer/Deck Controls/Show All" method="signal_activated"]
+[connection signal="deck_loading" from="VBoxContainer/MarginContainer2/PanelContainer2/HSplitContainer/Decks/DeckContainer" to="." method="load_decks"]
 [connection signal="deck_selected" from="VBoxContainer/MarginContainer2/PanelContainer2/HSplitContainer/Decks/DeckContainer" to="VBoxContainer/MarginContainer2/PanelContainer2/HSplitContainer/ScrollContainer/Cards" method="show_cards"]
 [connection signal="deck_unselected" from="VBoxContainer/MarginContainer2/PanelContainer2/HSplitContainer/Decks/DeckContainer" to="VBoxContainer/MarginContainer2/PanelContainer2/HSplitContainer/ScrollContainer/Cards" method="remove_all_cards"]
 [connection signal="decks_getting_placed" from="VBoxContainer/MarginContainer2/PanelContainer2/HSplitContainer/Decks/DeckContainer" to="VBoxContainer/MarginContainer2/PanelContainer2/HSplitContainer/ScrollContainer/Cards" method="decks_loaded"]

entities/ui/deck_viewer/scripts/DeckViewer.gd

@@ -4,8 +4,7 @@ signal decks_loading()
 signal deck_loading_done(decks: Array[MemoryDeckResource])
 signal scene_ready()
 
-func _ready() -> void:
-	load_decks()
+var _is_initial_load: bool = true
 
 func load_decks() -> void:
 	decks_loading.emit()
@@ -17,4 +16,7 @@ func cards_preloaded() -> void:
 	scene_ready.emit()
 
 func scene_is_ready() -> void:
+	if _is_initial_load:
+		await get_tree().physics_frame
+		_is_initial_load = false
 	scene_ready.emit()

entities/ui/deck_viewer/scripts/DeckViewerCards.gd

@@ -13,7 +13,6 @@ signal cards_preloaded()
 
 var is_initial_load: bool = true
 var current_deck: MemoryDeckResource = null
-var card_gen_thread: Thread = null
 
 func _ready() -> void:
 	if is_mobile():
@@ -81,31 +80,29 @@ func decks_loaded(decks: Array[MemoryDeckResource]) -> void:
 	clear_all_system_cards()
 
 	process_mode = Node.PROCESS_MODE_DISABLED
-	card_gen_thread = Thread.new()
-	card_gen_thread.start(get_cards_async.bind(decks, is_initial_load))
-	is_initial_load = false
+
 
-	await cards_preloaded
+	#await cards_preloaded
 
 	process_mode = Node.PROCESS_MODE_INHERIT
 
-	var data: Array[CardViewerTemplate] = card_gen_thread.wait_to_finish() as Array[CardViewerTemplate]
-	card_gen_thread = null
+	var data: Array[CardViewerTemplate] = await get_card_decks(decks)
 
 	for card: CardViewerTemplate in data:
 		var parent: Control = system_card_container
 		if card.built_in:
 			parent = built_in_card_container
 		parent.add_child(card)
 
-func get_cards_async(decks: Array[MemoryDeckResource], initial_load: bool) -> Array[CardViewerTemplate]:
+func get_card_decks(decks: Array[MemoryDeckResource]) -> Array[CardViewerTemplate]:
 	var return_data: Array[CardViewerTemplate] = []
 	for deck: MemoryDeckResource in decks:
-		if !deck.built_in or initial_load:
+		if !deck.built_in or is_initial_load:
 			return_data.append(load_cards_from_deck(deck))
-	initial_load = false
 
-	call_deferred("emit_signal","cards_preloaded")
+	cards_preloaded.emit()
+	await get_tree().physics_frame
+	is_initial_load = false
 	return return_data
 
 func load_cards_from_deck(deck: MemoryDeckResource) -> CardViewerTemplate:

entities/ui/edit_custom_deck/scripts/EditCustomDeck.gd

@@ -10,17 +10,6 @@ signal saved()
 
 var _resources: Array[CustomDeckResource] = []
 var _deck_loader: CustomDeckLoader = CustomDeckLoader.new()
-var _save_thread: Thread = null
-
-func _process(_delta: float) -> void:
-
-	if _save_thread == null or _save_thread.is_alive():
-		return
-	var result: bool = _save_thread.wait_to_finish() as bool
-	_save_thread = null
-	saved.emit()
-	if result:
-		GlobalGameManagerAccess.get_game_manager().reload_system_decks()
 
 func set_deck(deck: CustomDeckResource) -> void:
 	_resources.append(deck)
@@ -37,7 +26,6 @@ func delete_card(card: CustomDeckResource) -> void:
 		if card_resource.get_id() == card.get_id():
 			_resources.erase(card_resource)
 
-
 func add_or_update_card(card: CustomDeckResource) -> void:
 	for card_resource: CustomDeckResource in _resources:
 		if card_resource.get_id() == card.get_id():
@@ -50,7 +38,6 @@ func add_or_update_card(card: CustomDeckResource) -> void:
 	card.set_id(_get_next_card_id())
 	_resources.append(card)
 	card_added.emit(card)
-
 
 func _get_next_card_id() -> int:
 	var max_id: int = 0
@@ -59,12 +46,12 @@ func _get_next_card_id() -> int:
 			max_id = resource.get_id()
 	return max_id + 1
 
-
 func save_deck() -> void:
-	if _save_thread != null:
-		return
 	saving.emit()
-	_save_thread = _deck_loader.save_deck_async(get_deck(), _resources)
+	var save_successful: bool = await _deck_loader.save_deck(get_deck(), _resources)
+	saved.emit()
+	if save_successful:
+		GlobalGameManagerAccess.get_game_manager().reload_system_decks()
 
 func view_card(resource: CustomDeckResource) -> void:
 	var card: MemoryCardResource = _deck_loader.convert_to_playable_card(resource)

entities/ui/main_menu/scripts/MainMenu.gd

@@ -8,7 +8,6 @@ class_name MainMenu
 func _ready() -> void:
 	GlobalSystemDeckManager.loading_system_decks.connect(loading_cards)
 	GlobalSystemDeckManager.loading_system_decks.connect(loading_cards_done)
-	change_button_state(GlobalSystemDeckManager.is_loading())
 	get_tree().paused = false
 
 func loading_cards() -> void:

export_presets.cfg

@@ -1,8 +1,14 @@
+[runnable_presets]
+
+"Windows Desktop"="windows"
+Linux="linux"
+macOS="macOS"
+Web="Web"
+
 [preset.0]
 
 name="windows"
 platform="Windows Desktop"
-runnable=true
 dedicated_server=false
 custom_features=""
 export_filter="all_resources"
@@ -74,7 +80,6 @@ Remove-Item -Recurse -Force '{temp_dir}'"
 
 name="linux"
 platform="Linux"
-runnable=true
 dedicated_server=false
 custom_features=""
 export_filter="all_resources"
@@ -121,7 +126,6 @@ rm -rf \"{temp_dir}\""
 
 name="macOS"
 platform="macOS"
-runnable=true
 dedicated_server=false
 custom_features=""
 export_filter="all_resources"
@@ -386,7 +390,6 @@ application/min_macos_version="10.12"
 
 name="Web"
 platform="Web"
-runnable=true
 dedicated_server=false
 custom_features=""
 export_filter="all_resources"
@@ -411,7 +414,7 @@ script_export_mode=2
 custom_template/debug=""
 custom_template/release=""
 variant/extensions_support=false
-variant/thread_support=true
+variant/thread_support=false
 vram_texture_compression/for_desktop=true
 vram_texture_compression/for_mobile=false
 html/export_icon=true

shared/entities/clickable_button/resources/actions/StartGameAction.gd

@@ -12,4 +12,5 @@ func execute(base: ClickableButton) -> void:
 			template.name = template.ai_difficulty.get_translated_name()
 		player_templates.append(template)
 	var game_manager: GameManager = GlobalGameManagerAccess.get_game_manager()
-	game_manager.play_game_with_position(player_templates, game_manager.get_available_decks().pick_random(), base.get_global_center_position())
+	var decks: Array[MemoryDeckResource] = game_manager.get_available_decks()
+	game_manager.play_game_with_position(player_templates, decks.pick_random(), base.get_global_center_position())

shared/entities/custom_deck/scripts/CustomDeckLoader.gd

@@ -1,5 +1,7 @@
 class_name CustomDeckLoader extends Resource
 
+signal decks_loaded()
+
 var _max_image_width: float = 500
 var _max_image_height: float = 500
 var _base_path: String = "user://custom_decks/"
@@ -9,11 +11,6 @@ var _deck_information_file_name: String = "deck_info"
 var _card_base_path: String = "cards/"
 var _asset_base_folder: String = "assets/"
 
-func save_deck_async(deck_information: CustomDeckResource, deck_data: Array[CustomDeckResource]) -> Thread:
-	var thread: Thread = Thread.new()
-	thread.start(save_deck.bind(deck_information, deck_data))
-	return thread
-
 func save_deck(deck_information: CustomDeckResource, deck_data: Array[CustomDeckResource]) -> bool:
 	print("Saving deck with name: " + deck_information.get_resource_name())
 	var cards: Array[CustomDeckResource] = []
@@ -33,6 +30,7 @@ func save_deck(deck_information: CustomDeckResource, deck_data: Array[CustomDeck
 		save_card(packer,card)
 
 	packer.close()
+	await RenderingServer.frame_post_draw
 	return true
 
 func save_card(packer: ZIPPacker, card: CustomDeckResource) -> bool:
@@ -101,11 +99,6 @@ func convert_image_to_resource(real_texture: Texture2D) -> Texture2D:
 	scaled_texture.resize(new_image_size.x, new_image_size.y)
 	return ImageTexture.create_from_image(scaled_texture) as Texture2D
 
-func load_editable_deck_async(deck_path: String) -> Thread:
-	var thread: Thread = Thread.new()
-	thread.start(load_editable_deck.bind(deck_path)	)
-	return thread
-
 func load_editable_deck(deck_path: String) -> Array[CustomDeckResource]:
 	if not FileAccess.file_exists(deck_path):
 		return []
@@ -123,6 +116,7 @@ func load_editable_deck(deck_path: String) -> Array[CustomDeckResource]:
 				loaded_data.append(card_data)
 
 	reader.close()
+	await RenderingServer.frame_post_draw
 	return loaded_data
 
 func load_deck_information(reader: ZIPReader) -> CustomDeckResource:
@@ -182,13 +176,14 @@ func list_decks() -> Array[String]:
 func load_decks() -> Array[MemoryDeckResource]:
 	var return_decks: Array[MemoryDeckResource] = []
 	for deck: String in list_decks():
-		var playable_deck: MemoryDeckResource = load_playable_deck(deck)
+		var playable_deck: MemoryDeckResource = await load_playable_deck(deck)
 		if playable_deck != null and playable_deck.cards.size() > 2:
 			return_decks.append(playable_deck)
+	decks_loaded.emit()
 	return return_decks
 
 func load_playable_deck(deck_path: String) -> MemoryDeckResource:
-	var deck_data: Array[CustomDeckResource] = load_editable_deck(deck_path)
+	var deck_data: Array[CustomDeckResource] = await load_editable_deck(deck_path)
 	if deck_data.size() < 3:
 		return null
 
@@ -203,6 +198,7 @@ func load_playable_deck(deck_path: String) -> MemoryDeckResource:
 
 	var return_deck: MemoryDeckResource = MemoryDeckResource.new()
 	return_deck.built_in = false
+	return_deck.id = information.get_id()
 	return_deck.name = information.get_resource_name()
 	return_deck.description = information.get_description()
 	return_deck.card_back = information.loaded_texture