Add skill management system with unlocker and save functionality

scripts/components/damage_component.gd

@@ -4,6 +4,9 @@ extends Node
 @export var damage: float = 0.25
 @export var area2d: Area2D
 @export var status_effect_data: StatusEffectDataResource
+@export var damage_timer: Timer
+
+var current_target: Node = null
 signal effect_inflicted(target: Node2D, effect: StatusEffectDataResource)
 
 
@@ -13,13 +16,34 @@ func _ready() -> void:
 		return
 
 	area2d.body_entered.connect(on_area2d_body_entered)
+	area2d.body_exited.connect(on_area2d_body_exited)
+	area2d.area_entered.connect(on_area2d_area_entered)
+
+	if damage_timer:
+		damage_timer.timeout.connect(on_damage_timer_timeout)
+
+
+func _process(_delta: float) -> void:
+	if not current_target:
+		return
+	if damage_timer:
+		return
+
+	process_entity_and_apply_damage(current_target)
 
 
 func deal_damage(target: HealthComponent) -> void:
 	target.decrease_health(damage)
 
 
-func on_area2d_body_entered(body: Node2D) -> void:
+func on_damage_timer_timeout() -> void:
+	if not current_target:
+		return
+
+	process_entity_and_apply_damage(current_target)
+
+
+func process_entity_and_apply_damage(body: Node2D) -> void:
 	if body.has_node("HealthComponent"):
 		var health_component: HealthComponent                   = body.get_node("HealthComponent")
 		var invulnerability_component: InvulnerabilityComponent = body.get_node_or_null("InvulnerabilityComponent")
@@ -34,3 +58,27 @@ func on_area2d_body_entered(body: Node2D) -> void:
 
 		if invulnerability_component:
 			invulnerability_component.activate()
+
+
+func on_area2d_body_entered(body: Node2D) -> void:
+	current_target = body
+
+	if damage_timer:
+		damage_timer.start()
+
+	process_entity_and_apply_damage(body)
+
+
+func on_area2d_body_exited(body: Node2D) -> void:
+	if body == current_target:
+		current_target = null
+		if damage_timer:
+			damage_timer.stop()
+
+
+func on_area2d_area_entered(area: Area2D) -> void:
+	if area == area2d:
+		return
+	var parent := area.get_parent()
+	if parent.has_node("DamageComponent"):
+		process_entity_and_apply_damage(parent)

scripts/components/skill_unlocker_component.gd

@@ -0,0 +1,34 @@
+class_name SkillUnlockerComponent
+extends Node
+
+@export var skill_manager: SkillManager
+
+@onready var game_manager: GM = $"/root/GameManager"
+
+
+func try_unlock_skill(skill_data: SkillData) -> void:
+	if not game_manager:
+		return
+
+	if game_manager.is_skill_unlocked(skill_data.name):
+		return
+
+	if game_manager.get_coins() < skill_data.cost:
+		return
+
+	game_manager.remove_coins(skill_data.cost)
+	game_manager.unlock_skill(skill_data.name)
+	skill_manager.add_skill(skill_data)
+
+
+func _input(event: InputEvent) -> void:
+	if event.is_action_pressed("unlock_skills"):
+		var available_skills: Array[SkillData] = skill_manager.available_skills
+		var skills: Array[String]              = []
+
+		for skill in available_skills:
+			skills.append(skill.name)
+
+		game_manager.unlock_skills(skills)
+		skill_manager.apply_unlocked_skills()
+		print("Unlocked skills: ", skills)

scripts/game_manager.gd

@@ -4,6 +4,7 @@ extends Node
 var player_state = {
 					   "coins": 0,
 					   "lives": 3,
+					   "unlocked_skills": [],
 				   }
 
 
@@ -36,4 +37,18 @@ func set_lives(amount: int) -> void:
 
 
 func get_lives() -> int:
-	return player_state["lives"]
+	return player_state["lives"]
+
+
+func is_skill_unlocked(skill_name: String) -> bool:
+	return skill_name in player_state["unlocked_skills"]
+
+
+func unlock_skill(skill_name: String) -> void:
+	if not is_skill_unlocked(skill_name):
+		player_state["unlocked_skills"].append(skill_name)
+
+
+func unlock_skills(skill_names: Array[String]) -> void:
+	for skill_name in skill_names:
+		unlock_skill(skill_name)

scripts/resources/skill_data.gd

@@ -0,0 +1,9 @@
+class_name SkillData
+extends Resource
+
+@export var name: String = ""
+@export var description: String = ""
+@export var node: PackedScene
+@export var config: Dictionary = {}
+@export var cost: int = 0
+@export var icon: Texture2D

scripts/save_system.gd

@@ -0,0 +1,32 @@
+class_name SaveSystem
+extends Node
+
+@export var save_path: String = "user://savegame.save"
+@export var version: int = 1
+
+@onready var gm: GM = $"/root/GameManager"
+
+
+func save_game():
+	var save_data := {
+						 "player_state": gm.player_state,
+						 "version": version,
+					 }
+	var file      := FileAccess.open(save_path, FileAccess.WRITE)
+	file.store_var(save_data)
+	file.close()
+
+
+func load_game():
+	if not FileAccess.file_exists(save_path):
+		return
+	var file                  := FileAccess.open(save_path, FileAccess.READ)
+	var save_data: Dictionary =  file.get_var()
+	file.close()
+
+	if save_data.has("version") and save_data["version"] != version:
+		print("Save file version mismatch. Expected: ", version, ", Found: ", save_data["version"])
+		return
+
+	gm.player_state = save_data["player_state"]
+	gm.unlock_skills(gm.player_state["unlocked_skills"])

scripts/skill_manager.gd

@@ -0,0 +1,57 @@
+class_name SkillManager
+extends Node
+
+@export var available_skills: Array[SkillData] = []
+
+@onready var gm: GM = $"/root/GameManager"
+
+var active_components: Dictionary = {}
+
+
+func _ready() -> void:
+	apply_unlocked_skills()
+
+
+func add_skill(skill_data: SkillData) -> void:
+	if active_components.has(skill_data.name):
+		return
+
+	var skill_instance := skill_data.node.instantiate()
+	for key in skill_data.config.keys():
+		if key in skill_instance:
+			var value  =  skill_data.config[key]
+			var parent := get_parent()
+
+			if value is NodePath:
+				if parent.has_node(value):
+					value = parent.get_node(value)
+				elif skill_instance.has_node(value):
+					value = skill_instance.get_node(value)
+				else:
+					print("NodePath not found: ", value)
+					continue
+
+			skill_instance[key] = value
+
+	add_child(skill_instance)
+	active_components[skill_data.name] = skill_instance
+
+
+func remove_skill(skill_name: String) -> void:
+	if not active_components.has(skill_name):
+		return
+
+	var skill_instance = active_components[skill_name]
+	if is_instance_valid(skill_instance):
+		skill_instance.queue_free()
+
+	active_components.erase(skill_name)
+
+
+func apply_unlocked_skills() -> void:
+	for skill_data in available_skills:
+		if gm.is_skill_unlocked(skill_data.name):
+			print("Applying skill: ", skill_data.name)
+			add_skill(skill_data)
+		else:
+			remove_skill(skill_data.name)