Decouple Fuel System using GameSettingsResource and Signals

scripts/game_settings_resource.gd

@@ -15,6 +15,32 @@ extends Resource
 ## without the UI having to explicitly call persistence or logging methods.
 signal setting_changed(setting_name: String, new_value: Variant)
 
+## SIGNAL: fuel_depleted
+##
+## Emitted when current_fuel reaches exactly 0.0.
+## External systems (like the Player or UI) can connect to this to trigger
+## game-over states or low-fuel warnings without polling every frame.
+signal fuel_depleted
+
+@export_group("Fuel System")
+## Maximum fuel capacity.
+@export var max_fuel: float = 100.0:
+	set(value):
+		max_fuel = max(0.0, value)
+		setting_changed.emit("max_fuel", max_fuel)
+
+## Current fuel level. Clamped between 0.0 and max_fuel.
+@export var current_fuel: float = 100.0:
+	set(value):
+		var old_value: float = current_fuel
+		current_fuel = clamp(value, 0.0, max_fuel)
+		if old_value > 0.0 and current_fuel == 0.0:
+			fuel_depleted.emit()
+		setting_changed.emit("current_fuel", current_fuel)
+
+## Base rate of fuel consumption per second.
+@export var base_consumption_rate: float = 1.0
+
 @export_group("Logging")
 # Current log level: 0=DEBUG, 1=INFO, 2=WARNING, 3=ERROR, 4=NONE
 @export_range(0, 4, 1) var current_log_level: int = 1:
@@ -69,3 +95,10 @@ func _init() -> void:
 		key_mapping_scene = load("res://scenes/key_mapping_menu.tscn")
 	if not options_scene:
 		options_scene = load("res://scenes/options_menu.tscn")
+
+
+## Helper method to increase fuel safely.
+## Increases fuel level by specified amount, clamped to max_fuel.
+func refuel(amount: float) -> void:
+	if amount > 0:
+		current_fuel += amount

scripts/globals.gd

@@ -202,6 +202,26 @@ func _load_settings(path: String = Settings.CONFIG_PATH) -> void:
 					LogLevel.DEBUG
 				)
 
+		# NEW: Load the fuel related settings
+		if config.has_section_key("Settings", "max_fuel"):
+			var loaded_max: Variant = config.get_value("Settings", "max_fuel")
+			if loaded_max is float or loaded_max is int:
+				settings.max_fuel = float(loaded_max)
+			else:
+				log_message(
+					"Invalid type for max_fuel: " + str(typeof(loaded_max)), LogLevel.WARNING
+				)
+
+		if config.has_section_key("Settings", "current_fuel"):
+			var loaded_current: Variant = config.get_value("Settings", "current_fuel")
+			if loaded_current is float or loaded_current is int:
+				settings.current_fuel = float(loaded_current)
+			else:
+				log_message(
+					"Invalid type for current_fuel: " + str(typeof(loaded_current)),
+					LogLevel.WARNING
+				)
+
 		# Disable the guard and log a single summary instead
 		_is_loading_settings = false
 		log_message("All settings loaded and synchronized.", LogLevel.DEBUG)
@@ -226,6 +246,10 @@ func _save_settings(path: String = Settings.CONFIG_PATH) -> void:
 	config.set_value("Settings", "difficulty", settings.difficulty)
 	# NEW: Persist the debug logging flag
 	config.set_value("Settings", "enable_debug_logging", settings.enable_debug_logging)
+	# NEW: Persist the fuel settings
+	config.set_value("Settings", "max_fuel", settings.max_fuel)
+	config.set_value("Settings", "current_fuel", settings.current_fuel)
+
 	err = config.save(path)
 	if err != OK:
 		log_message("Failed to save settings: " + str(err), LogLevel.ERROR)

scripts/main_scene.gd

@@ -188,9 +188,16 @@ func setup_decor_layer(viewport: Vector2) -> void:
 func _process(delta: float) -> void:
 	var scroll_speed: float = player.speed["speed"] * delta * Globals.settings.difficulty * 0.8
 	background.scroll_offset.y += scroll_speed
-	if player.fuel["fuel"] <= 0:
+
+	# OLD: if player.fuel["fuel"] <= 0:
+	# NEW: Check the global settings resource for current fuel,
+	# since the local dictionary key was removed.
+	if Globals.settings.current_fuel <= 0:
 		background.scroll_offset = Vector2(0, 0)
 
+	# 1. Critical unbound controls warning (shown ONCE per session)
+	# Flag stays true until player fixes bindings (e.g., in key_mapping.gd after remap).
+
 	# 1. Critical unbound controls warning (shown ONCE per session)
 	# Flag stays true until player fixes bindings (e.g., in key_mapping.gd after remap).
 	# Do NOT reset here — that would make it repeat every 4s (bug fixed).

scripts/player.gd

@@ -42,8 +42,8 @@ const BLINK_INTERVAL: float = 0.5  # Seconds between blinks
 @export var acceleration: float = 200.0
 @export var deceleration: float = 100.0
 # Base fuel consumption
-@export var base_fuel_drain: float = 1.0
-var current_fuel: float
+# OLD: @export var base_fuel_drain: float = 1.0
+# OLD: var current_fuel: float
 
 # Regular vars for computed boundaries (no export needed if set in code)
 var screen_size: Vector2
@@ -139,18 +139,31 @@ func _ready() -> void:
 	# Initialize fuel bar style
 	fuel_bar_fill_style = StyleBoxFlat.new()
 	set_bar_fill_style(fuel_bar, fuel_bar_fill_style)
-	fuel_bar.max_value = MAX_FUEL
+	# OLD: fuel_bar.max_value = MAX_FUEL
+	# NEW: Ensure the UI max capacity pulls directly from
+	# the centralized GameSettingsResource.
+	fuel_bar.max_value = Globals.settings.max_fuel
+
+	# NEW: Reset the fuel to maximum every time the player spawns
+	# so a new game always starts with a full tank.
+	Globals.settings.current_fuel = Globals.settings.max_fuel
 
 	# Initialize speed bar style and value
 	speed_bar_fill_style = StyleBoxFlat.new()
 	set_bar_fill_style(speed_bar, speed_bar_fill_style)
 	speed_bar.max_value = MAX_SPEED
 
 	# Initialize fuel bar style and value
-	current_fuel = MAX_FUEL
+	# OLD: current_fuel = MAX_FUEL
 	fuel_timer.timeout.connect(_on_fuel_timer_timeout)
 	fuel_timer.start()
 
+	# NEW: Connect to the global fuel_depleted signal to handle engine failure.
+	Globals.settings.fuel_depleted.connect(_on_player_out_of_fuel)
+	# NEW: Connect to the global setting_changed signal so the UI
+	# reacts to refuels/drains automatically.
+	Globals.settings.setting_changed.connect(_on_setting_changed)
+
 	speed = {
 		"speed": 250.0,  # Initial speed value (mph); was current_speed
 		"lateral_speed": lateral_speed,
@@ -167,11 +180,11 @@ func _ready() -> void:
 	}
 
 	fuel = {
-		"fuel": current_fuel,
+		# OLD: "fuel": current_fuel,
 		"factor": 0.0,
 		"timer": fuel_label_blink_timer,
 		"label": fuel_label,
-		"max": MAX_FUEL,
+		# OLD: "max": MAX_FUEL,
 		"bar": fuel_bar,
 		"bar style": fuel_bar_fill_style,
 		"blinking": false,
@@ -210,6 +223,27 @@ func _ready() -> void:
 		push_error("Weapon node not found! Check player.tscn scene tree for $Weapon child.")
 
 
+# NEW: Observer pattern handler to react when GameSettingsResource
+# properties (like fuel) are updated externally.
+func _on_setting_changed(setting_name: String, _value: Variant) -> void:
+	if setting_name == "current_fuel":
+		update_fuel_bar()
+		check_fuel_warning()
+
+
+# NEW: Handler for engine failure triggered by the global fuel_depleted signal from the resource.
+func _on_player_out_of_fuel() -> void:
+	Globals.log_message("Player is out of fuel! Engine flameout.", Globals.LogLevel.WARNING)
+
+	# OLD: speed["speed"] = 0.0 (This was previously inside _on_fuel_timer_timeout)
+	# NEW: Migrated the speed reset to ensure the plane actually stops flying when fuel hits 0
+	speed["speed"] = 0.0
+
+	rotor_stop(rotor_right, rotor_right_sfx)
+	rotor_stop(rotor_left, rotor_left_sfx)
+	fuel_timer.stop()
+
+
 ## Retrieves the effective text color of a Label, considering theme overrides.
 ## @param label: The Label node to query.
 ## @return: The effective font color.
@@ -284,8 +318,15 @@ func rotor_stop(rotor: Node2D, rotor_sfx: AudioStreamPlayer2D) -> void:
 
 
 func update_fuel_bar() -> void:
-	fuel["bar"].value = fuel["fuel"]
-	var fuel_percent: float = (fuel["fuel"] / fuel["max"]) * 100.0
+	# OLD: fuel["bar"].value = fuel["fuel"]
+	# OLD: var fuel_percent: float = (fuel["fuel"] / fuel["max"]) * 100.0
+
+	# NEW: Explicitly read current and max fuel from the global settings resource.
+	var cur_fuel: float = Globals.settings.current_fuel
+	var m_fuel: float = Globals.settings.max_fuel
+
+	fuel["bar"].value = cur_fuel
+	var fuel_percent: float = (cur_fuel / m_fuel) * 100.0
 
 	if fuel_percent > HIGH_FUEL_THRESHOLD:
 		fuel["factor"] = 0.0  # Reset for consistency, though not used here
@@ -355,33 +396,47 @@ func update_speed_bar() -> void:
 
 # Connect Timer's timeout signal
 func _on_fuel_timer_timeout() -> void:
-	# Scale base rate with clamped normalized speed
-	# to avoid excessive drain at out-of-range speeds
+	# OLD: # Scale base rate with clamped normalized speed
+	# OLD: # to avoid excessive drain at out-of-range speeds
+	# OLD: var normalized_speed: float = clamp(speed["speed"] / MAX_SPEED, 0.0, 1.0)
+	# OLD: var fuel_left: float = (
+	# OLD: 	fuel["fuel"] - ((base_fuel_drain * normalized_speed) * Globals.settings.difficulty)
+	# OLD: )
+	# OLD: #
+	# OLD: # Clamp and update current_fuel first
+	# OLD: fuel["fuel"] = clamp(fuel_left, 0, fuel["max"])
+	# OLD:
+	# OLD: if fuel["fuel"] <= 0:
+	# OLD: 	speed["speed"] = 0.0  # Or game over logic
+	# OLD: 	fuel_timer.stop()
+	# OLD: 	rotor_stop(rotor_right, rotor_right_sfx)
+	# OLD: 	rotor_stop(rotor_left, rotor_left_sfx)
+	# OLD:
+	# OLD: # Update UI from the clamped value
+	# OLD: update_fuel_bar()
+	# OLD: # Check fuel level and start/stop blinking
+	# OLD: check_fuel_warning()
+	# OLD: Globals.log_message("Fuel left: " + str(fuel["fuel"]), Globals.LogLevel.DEBUG)
+
+	# NEW: Calculate depletion based on Global settings and update the resource directly.
+	# NEW: Game over logic is now handled by _on_player_out_of_fuel via the fuel_depleted signal.
+	# NEW: UI updates are handled automatically via the setting_changed signal.
 	var normalized_speed: float = clamp(speed["speed"] / MAX_SPEED, 0.0, 1.0)
-	var fuel_left: float = (
-		fuel["fuel"] - ((base_fuel_drain * normalized_speed) * Globals.settings.difficulty)
+	var consumption: float = (
+		Globals.settings.base_consumption_rate * normalized_speed * Globals.settings.difficulty
 	)
-	#
-	# Clamp and update current_fuel first
-	fuel["fuel"] = clamp(fuel_left, 0, fuel["max"])
-
-	if fuel["fuel"] <= 0:
-		speed["speed"] = 0.0  # Or game over logic
-		fuel_timer.stop()
-		rotor_stop(rotor_right, rotor_right_sfx)
-		rotor_stop(rotor_left, rotor_left_sfx)
-
-	# Update UI from the clamped value
-	update_fuel_bar()
-	# Check fuel level and start/stop blinking
-	check_fuel_warning()
-	Globals.log_message("Fuel left: " + str(fuel["fuel"]), Globals.LogLevel.DEBUG)
+	Globals.settings.current_fuel -= consumption
+	Globals.log_message("Fuel left: " + str(Globals.settings.current_fuel), Globals.LogLevel.DEBUG)
 
 
 func check_fuel_warning() -> void:
-	if fuel["fuel"] <= LOW_FUEL_THRESHOLD and not fuel["blinking"]:
+	# OLD: if fuel["fuel"] <= LOW_FUEL_THRESHOLD and not fuel["blinking"]:
+	# NEW: Read from global resource instead of local dictionary
+	if Globals.settings.current_fuel <= LOW_FUEL_THRESHOLD and not fuel["blinking"]:
 		start_blinking(fuel)
-	elif fuel["fuel"] > LOW_FUEL_THRESHOLD and fuel["blinking"]:
+	# OLD: elif fuel["fuel"] > LOW_FUEL_THRESHOLD and fuel["blinking"]:
+	# NEW: Read from global resource instead of local dictionary
+	elif Globals.settings.current_fuel > LOW_FUEL_THRESHOLD and fuel["blinking"]:
 		stop_blinking(fuel)
 
 
@@ -435,29 +490,44 @@ func _toggle_label(param: Dictionary) -> void:
 
 func _physics_process(_delta: float) -> void:
 	# Speed changes allowed only if fuel > 0
-	if Input.is_action_pressed("speed_up") and fuel["fuel"] > 0:
+	# OLD: if Input.is_action_pressed("speed_up") and fuel["fuel"] > 0:
+	# NEW: Check global resource fuel instead of local dictionary
+	if Input.is_action_pressed("speed_up") and Globals.settings.current_fuel > 0:
 		speed["speed"] += speed["acceleration"] * _delta
-	if Input.is_action_pressed("speed_down") and fuel["fuel"] > 0:
+
+	# OLD: if Input.is_action_pressed("speed_down") and fuel["fuel"] > 0:
+	# NEW: Check global resource fuel instead of local dictionary
+	if Input.is_action_pressed("speed_down") and Globals.settings.current_fuel > 0:
 		speed["speed"] -= speed["deceleration"] * _delta
+
 	# Clamp current_speed between MIN_SPEED and MAX_SPEED
-	if fuel["fuel"] == 0:
+	# OLD: if fuel["fuel"] == 0:
+	# NEW: Check global resource fuel instead of local dictionary
+	if Globals.settings.current_fuel == 0:
 		# No fuel left, airplane can't fly
 		speed["speed"] = clamp(speed["speed"], 0, speed["max"])
 	else:
 		speed["speed"] = clamp(speed["speed"], speed["min"], speed["max"])
+
 	# Left/Right movement
 	var lateral_input: float = Input.get_axis("move_left", "move_right")
+
 	# Left/Right movement, only allowed when fuel > 0 and the player is moving
-	if lateral_input and fuel["fuel"] > 0 and speed["speed"] > 0:
+	# OLD: if lateral_input and fuel["fuel"] > 0 and speed["speed"] > 0:
+	# NEW: Check global resource fuel instead of local dictionary
+	if lateral_input and Globals.settings.current_fuel > 0 and speed["speed"] > 0:
 		player.velocity.x = lateral_input * speed["lateral_speed"]
 	# Reset lateral velocity if no input
 	else:
 		player.velocity.x = 0.0
+
 	# Clamp player position within allowed ranged of coords
 	player.position.x = clamp(player.position.x, player_x_min, player_x_max)
 	player.position.y = clamp(player.position.y, player_y_min, player_y_max)
+
 	# Update UI
 	update_speed_bar()
 	check_speed_warning()
+
 	# Perform player movement
 	player.move_and_slide()

test/gdunit4/test_difficulty.gd

@@ -30,23 +30,50 @@ func test_fuel_depletion_with_difficulty() -> void:
 	var original_difficulty: float = Globals.settings.difficulty
 
 	# Reset fuel before each sim for independent tests
-	player_inst.fuel["fuel"] = 100.0
+	# OLD: player_inst.fuel["fuel"] = 100.0
+	# NEW: Reset the global fuel resource instead of the local dictionary
+	Globals.settings.current_fuel = 100.0
 	Globals.settings.difficulty = 1.0
 	var normalized_speed: float = player_inst.speed["speed"] / player_inst.MAX_SPEED
-	var dep_1: float = player_inst.base_fuel_drain * normalized_speed * Globals.settings.difficulty
+
+	# OLD: var dep_1: float = player_inst.base_fuel_drain * normalized_speed * Globals.settings.difficulty
+	# NEW: Use the global base_consumption_rate instead of the removed local base_fuel_drain
+	var dep_1: float = Globals.settings.base_consumption_rate * normalized_speed * Globals.settings.difficulty
+
 	player_inst._on_fuel_timer_timeout()
-	assert_float(player_inst.fuel["fuel"]).is_equal_approx(100.0 - dep_1, 0.01)  # Larger delta for precision
 
-	player_inst.fuel["fuel"] = 100.0
+	# OLD: assert_float(player_inst.fuel["fuel"]).is_equal_approx(100.0 - dep_1, 0.01)  # Larger delta for precision
+	# NEW: Assert against the global fuel resource instead of the local dictionary
+	assert_float(Globals.settings.current_fuel).is_equal_approx(100.0 - dep_1, 0.01)
+
+	# OLD: player_inst.fuel["fuel"] = 100.0
+	# NEW: Reset the global fuel resource for the second test
+	Globals.settings.current_fuel = 100.0
 	Globals.settings.difficulty = 2.0
 	normalized_speed = player_inst.speed["speed"] / player_inst.MAX_SPEED  # Re-derive
-	var dep_2: float = player_inst.base_fuel_drain * normalized_speed * Globals.settings.difficulty
+
+	# OLD: var dep_2: float = player_inst.base_fuel_drain * normalized_speed * Globals.settings.difficulty
+	# NEW: Use the global base_consumption_rate instead of the removed local base_fuel_drain
+	var dep_2: float = Globals.settings.base_consumption_rate * normalized_speed * Globals.settings.difficulty
+
 	player_inst._on_fuel_timer_timeout()
-	assert_float(player_inst.fuel["fuel"]).is_equal_approx(100.0 - dep_2, 0.01)
 
-	player_inst.fuel["fuel"] = 100.0
+	# OLD: assert_float(player_inst.fuel["fuel"]).is_equal_approx(100.0 - dep_2, 0.01)
+	# NEW: Assert against the global fuel resource
+	assert_float(Globals.settings.current_fuel).is_equal_approx(100.0 - dep_2, 0.01)
+
+	# OLD: player_inst.fuel["fuel"] = 100.0
+	# NEW: Reset the global fuel resource for the third test
+	Globals.settings.current_fuel = 100.0
 	Globals.settings.difficulty = 0.5
 	normalized_speed = player_inst.speed["speed"] / player_inst.MAX_SPEED
-	var dep_05: float = player_inst.base_fuel_drain * normalized_speed * Globals.settings.difficulty
+
+	# OLD: var dep_05: float = player_inst.base_fuel_drain * normalized_speed * Globals.settings.difficulty
+	# NEW: Use the global base_consumption_rate instead of the removed local base_fuel_drain
+	var dep_05: float = Globals.settings.base_consumption_rate * normalized_speed * Globals.settings.difficulty
+
 	player_inst._on_fuel_timer_timeout()
-	assert_float(player_inst.fuel["fuel"]).is_equal_approx(100.0 - dep_05, 0.01)
+
+	# OLD: assert_float(player_inst.fuel["fuel"]).is_equal_approx(100.0 - dep_05, 0.01)
+	# NEW: Assert against the global fuel resource
+	assert_float(Globals.settings.current_fuel).is_equal_approx(100.0 - dep_05, 0.01)