chore: format GDScript files

src/Composer/Composer.gd

@@ -6,7 +6,7 @@ extends Node
 ## the option to have a loading screen and the transfer of data between scenes.
 
 ## Emitted when Composer has been fully initialised, alongside with its timer.
-signal finished_initialising()
+signal finished_initialising
 
 ## Emitted when provided scene has been invalid (may not exist or path is invalid).
 signal invalid_scene(path: String)
@@ -22,7 +22,7 @@ signal finished_loading(scene: Node)
 
 ## Use with loading screens, for scene activation (i.e making scene visible or activating certain game logic).
 @warning_ignore("unused_signal")
-signal loading_activated()
+signal loading_activated
 
 ## Tracks if composer finished initializing; i.e when its ready to use.
 var has_initialized: bool = false:
@@ -42,7 +42,8 @@ var cache_mode: ResourceLoader.CacheMode = ResourceLoader.CACHE_MODE_REUSE
 ## This should not be changed unless absolutely necessary.
 var loading_timer_delay: float = 0.1:
 	set(val):
-		if !has_initialized: await finished_initialising
+		if !has_initialized:
+			await finished_initialising
 
 		loading_timer_delay = val
 		_loading_timer.wait_time = loading_timer_delay
@@ -60,6 +61,7 @@ var _current_scene: Node = null
 
 var _current_data: Dictionary = {}
 
+
 func _enter_tree() -> void:
 	invalid_scene.connect(_on_invalid_scene)
 	failed_loading.connect(_on_failed_loading)
@@ -68,22 +70,28 @@ func _enter_tree() -> void:
 	root = get_tree().root
 	_setup_timer()
 
+
 ## Replaces the current scene with a new scene using a path,
 ## can also be used for transferring data between scenes with the optional data_to_transfer
 ## parameter. Data will be stored as new scene metadata, named "transferred_data".
 func load_scene(path_to_scene: String, data_to_transfer: Dictionary = {}) -> void:
-	if _is_loading: return
+	if _is_loading:
+		return
 
-	if !has_initialized: await finished_initialising
+	if !has_initialized:
+		await finished_initialising
 
-	var loader: Error = ResourceLoader.load_threaded_request(path_to_scene, "", is_using_subthreads, cache_mode)
+	var loader: Error = ResourceLoader.load_threaded_request(
+		path_to_scene, "", is_using_subthreads, cache_mode
+	)
 	if not ResourceLoader.exists(path_to_scene) or loader == null:
 		invalid_scene.emit(path_to_scene)
 		return
 
 	_is_loading = true
 
-	if _loading_timer == null: _setup_timer()
+	if _loading_timer == null:
+		_setup_timer()
 
 	if _current_scene:
 		_current_scene.queue_free()
@@ -93,28 +101,34 @@ func load_scene(path_to_scene: String, data_to_transfer: Dictionary = {}) -> voi
 	_current_data = data_to_transfer
 	_loading_timer.start()
 
+
 ## Creates a loading screen using a path and adds it to the SceneTree.
 ## Returns an instance of it for usage with signals.
 func setup_load_screen(path_to_load_screen: String) -> Node:
-	if _has_loading_screen: return
+	if _has_loading_screen:
+		return
 
 	_has_loading_screen = true
 	_current_load_screen = load(path_to_load_screen).instantiate()
 
-	root.call_deferred("add_child",_current_load_screen)
-	root.call_deferred("move_child",_current_load_screen, get_child_count()-1)
+	root.call_deferred("add_child", _current_load_screen)
+	root.call_deferred("move_child", _current_load_screen, get_child_count() - 1)
 
 	return _current_load_screen
 
+
 ## Gets rid of the loading screen.
 func clear_load_screen() -> void:
 	_current_load_screen.queue_free()
 	_current_load_screen = null
 	_has_loading_screen = false
 
+
 func _check_loading_status() -> void:
 	var load_progress: Array = []
-	var load_status: ResourceLoader.ThreadLoadStatus = ResourceLoader.load_threaded_get_status(_current_loading_path, load_progress)
+	var load_status: ResourceLoader.ThreadLoadStatus = ResourceLoader.load_threaded_get_status(
+		_current_loading_path, load_progress
+	)
 
 	match load_status:
 		ResourceLoader.THREAD_LOAD_INVALID_RESOURCE:
@@ -129,19 +143,23 @@ func _check_loading_status() -> void:
 			updated_loading.emit(_current_loading_path, int(load_progress[0] * 100))
 		ResourceLoader.THREAD_LOAD_LOADED:
 			_loading_timer.stop()
-			finished_loading.emit(ResourceLoader.load_threaded_get(_current_loading_path).instantiate())
+			finished_loading.emit(
+				ResourceLoader.load_threaded_get(_current_loading_path).instantiate()
+			)
+
 
 func _setup_timer() -> void:
 	_loading_timer = Timer.new()
 	_loading_timer.name = "LoadingTimer"
 	_loading_timer.wait_time = 0.1
 	_loading_timer.timeout.connect(_check_loading_status)
-	root.call_deferred("add_child",_loading_timer)
+	root.call_deferred("add_child", _loading_timer)
 
 	await _loading_timer.ready
 
 	has_initialized = true
 
+
 func _on_finished_loading(scene: Node) -> void:
 	scene.set_meta("transferred_data", _current_data)
 
@@ -152,8 +170,10 @@ func _on_finished_loading(scene: Node) -> void:
 	_is_loading = false
 	_current_data = {}
 
+
 func _on_invalid_scene(path: String) -> void:
 	printerr("Error: Invalid resource: " + path)
 
+
 func _on_failed_loading(path: String) -> void:
 	printerr("Error: Failed to load resource: " + path)

src/Composer/LoadingScreens/Fade/fade_screen.gd

@@ -1,36 +1,40 @@
 extends CanvasLayer
 
-signal finished_fade_in()
+signal finished_fade_in
 
 @onready var fade_rect: ColorRect = $FadeRect
 
 var fade_tween: Tween
 
+
 func _ready() -> void:
 	fade_in()
 	Composer.finished_loading.connect(_on_finished_loading)
 
+
 func fade_in() -> void:
-	fade_rect.color = Color(0,0,0,0)
+	fade_rect.color = Color(0, 0, 0, 0)
 
 	fade_tween = get_tree().create_tween()
-	fade_tween.tween_property(fade_rect,"color:a",1.0,0.75)
+	fade_tween.tween_property(fade_rect, "color:a", 1.0, 0.75)
 	fade_tween.tween_callback(
 		func() -> void:
 			fade_tween.kill()
 			finished_fade_in.emit()
 	)
 
+
 func fade_out() -> void:
-	fade_rect.color = Color(0,0,0,1)
+	fade_rect.color = Color(0, 0, 0, 1)
 
 	fade_tween = get_tree().create_tween()
-	fade_tween.tween_property(fade_rect,"color:a",0.0,0.75)
+	fade_tween.tween_property(fade_rect, "color:a", 0.0, 0.75)
 	fade_tween.tween_callback(
 		func() -> void:
 			fade_tween.kill()
 			Composer.clear_load_screen()
 	)
 
+
 func _on_finished_loading(_scene: Node) -> void:
 	fade_out()

src/Composer/LoadingScreens/ZigZag/zig_zag_screen.gd

@@ -6,12 +6,13 @@ var height: int = ProjectSettings.get_setting("display/window/size/viewport_heig
 var color: Color = Color.BLACK
 var points: PackedVector2Array = []
 
+
 func setup_zigzag() -> void:
 	var temp_array: PackedVector2Array = []
 
 	var x: int = width
 	var y: int = 0
-	points.append(Vector2(x,y))
+	points.append(Vector2(x, y))
 	temp_array.append(Vector2(x - (width + 64), y))
 
 	while y <= height * 2:
@@ -21,13 +22,14 @@ func setup_zigzag() -> void:
 		else:
 			x -= 32
 
-		points.append(Vector2(x,y))
+		points.append(Vector2(x, y))
 		temp_array.append(Vector2(x - (width + 64), y))
 
 	temp_array.reverse()
 	points.append_array(temp_array)
 
 	global_position = Vector2(-width, 0)
 
+
 func _draw() -> void:
 	draw_polygon(points, [color])

src/Composer/LoadingScreens/ZigZag/zig_zag_screen_boot.gd

@@ -1,38 +1,42 @@
 class_name ZigZag extends CanvasLayer
 
-signal finished_moving()
+signal finished_moving
 
 @onready var control: Control = $Control
 
 var zigzag_tween: Tween
 
+
 func _ready() -> void:
 	control.setup_zigzag()
 	move_to_center()
 
 	Composer.finished_loading.connect(_on_finished_loading)
 
+
 func move_to_center() -> void:
 	zigzag_tween = get_tree().create_tween()
 	zigzag_tween.set_trans(Tween.TRANS_QUAD)
-	zigzag_tween.tween_property(control,"global_position:x",0,0.75)
+	zigzag_tween.tween_property(control, "global_position:x", 0, 0.75)
 	zigzag_tween.tween_callback(
 		func() -> void:
 			zigzag_tween.kill()
 			finished_moving.emit()
 	)
 
+
 func move_to_back() -> void:
 	control.global_position = Vector2(0, 0)
 
 	zigzag_tween = get_tree().create_tween()
 	zigzag_tween.set_trans(Tween.TRANS_QUAD)
-	zigzag_tween.tween_property(control,"global_position:x",control.width,0.75)
+	zigzag_tween.tween_property(control, "global_position:x", control.width, 0.75)
 	zigzag_tween.tween_callback(
 		func() -> void:
 			zigzag_tween.kill()
 			Composer.clear_load_screen()
 	)
 
+
 func _on_finished_loading(_scene: Node) -> void:
 	move_to_back()

src/Game/Enemies/Barnacle/barnacle.gd

@@ -7,15 +7,18 @@ class_name Barnacle extends Enemy
 
 var movement_tween: Tween
 
+
 func _ready() -> void:
 	show_timer.start()
 
+
 func kill() -> void:
 	if movement_tween != null:
 		movement_tween.pause()
 
 	super()
 
+
 func collision_check(body: Node2D) -> void:
 	if body.is_in_group("Player"):
 		if Globals.player.is_immune:
@@ -42,21 +45,23 @@ func collision_check(body: Node2D) -> void:
 					player_hit.emit(false)
 					kill()
 
+
 func _on_show_timer_timeout() -> void:
 	animated_sprite_2d.play("close")
 	movement_tween = get_tree().create_tween()
-	movement_tween.tween_property(self, "global_position:y",global_position.y-172, 1.5)
+	movement_tween.tween_property(self, "global_position:y", global_position.y - 172, 1.5)
 	movement_tween.tween_callback(
 		func() -> void:
 			animated_sprite_2d.play("open")
 			hide_timer.start()
 			movement_tween.kill()
 	)
 
+
 func _on_hide_timer_timeout() -> void:
 	animated_sprite_2d.play("close")
 	movement_tween = get_tree().create_tween()
-	movement_tween.tween_property(self, "global_position:y",global_position.y+172, 1.5)
+	movement_tween.tween_property(self, "global_position:y", global_position.y + 172, 1.5)
 	movement_tween.tween_callback(
 		func() -> void:
 			show_timer.wait_time = 1.5 + randf_range(1.0, max_delay)

src/Game/Enemies/Bat/bat.gd

@@ -7,16 +7,19 @@ var movement_tween: Tween
 var initial_pos: Vector2
 var ray2_collider: Node
 
+
 func _ready() -> void:
 	initial_pos = global_position
 	animated_sprite_2d.play("hang")
 
+
 func kill() -> void:
 	if movement_tween != null:
 		movement_tween.pause()
 
 	super()
 
+
 func move(delta: float) -> void:
 	# Move the bat towards the player when detected
 	if player_ray.is_colliding():
@@ -46,6 +49,7 @@ func move(delta: float) -> void:
 		ray2_collider = null
 		player_tracked_stopped.emit()
 
+
 func collision_check(body: Node2D) -> void:
 	if body.is_in_group("Player"):
 		if Globals.player.is_immune:
@@ -63,13 +67,16 @@ func collision_check(body: Node2D) -> void:
 					player_hit.emit(false)
 					kill()
 
+
 func _on_player_tracked() -> void:
 	if not is_chasing:
 		is_chasing = true
 
 		# Calculate the bat's target position and flight time.
-		var desired_pos: Vector2 = Vector2(Globals.player.global_position.x, Globals.player.global_position.y)
-		var fly_time: float = clampf((desired_pos.y - initial_pos.y)/2000, 1, 1.5)
+		var desired_pos: Vector2 = Vector2(
+			Globals.player.global_position.x, Globals.player.global_position.y
+		)
+		var fly_time: float = clampf((desired_pos.y - initial_pos.y) / 2000, 1, 1.5)
 		animated_sprite_2d.play("fly")
 
 		movement_tween = get_tree().create_tween()