update

systems/shield_system.gd

@@ -1,10 +1,28 @@
 extends Node
 
 func _process(delta: float) -> void:
-  for entity in Stats.entities:
+  _process_player(delta)
+  _process_entities(delta, EnemyData.entities)
+  _process_entities(delta, BossData.entities)
+
+func _process_player(delta: float) -> void:
+  if not PlayerData.alive or PlayerData.max_shield <= 0:
+    return
+  if PlayerData.shield < PlayerData.max_shield:
+    PlayerData.shield_regen_timer += delta
+    if PlayerData.shield_regen_timer >= PlayerData.shield_regen_delay:
+      var regen_rate: float = PlayerData.max_shield / PlayerData.shield_regen_time
+      var shield: float = PlayerData.shield + regen_rate * delta
+      if shield >= PlayerData.max_shield:
+        shield = PlayerData.max_shield
+        EventBus.shield_regenerated.emit(get_tree().get_first_node_in_group("player"))
+      PlayerData.set_shield(shield)
+
+func _process_entities(delta: float, entities: Dictionary) -> void:
+  for entity in entities:
     if not is_instance_valid(entity):
       continue
-    var data: Dictionary = Stats.entities[entity]
+    var data: Dictionary = entities[entity]
     if not data["alive"]:
       continue
     var max_shield: float = data["max_shield"]
@@ -22,17 +40,35 @@ func _process(delta: float) -> void:
         data["shield"] = shield
         EventBus.shield_changed.emit(entity, shield, max_shield)
 
-func absorb(entity: Node, amount: float) -> float:
-  var shield: float = Stats.get_stat(entity, "shield")
+func absorb(target: Node, amount: float) -> float:
+  var player: Node = get_tree().get_first_node_in_group("player")
+  if target == player:
+    if PlayerData.shield <= 0:
+      return amount
+    PlayerData.shield_regen_timer = 0.0
+    var absorbed: float = min(amount, PlayerData.shield)
+    var shield: float = PlayerData.shield - absorbed
+    PlayerData.set_shield(shield)
+    if shield <= 0:
+      EventBus.shield_broken.emit(target)
+    return amount - absorbed
+  var data_source: Node = _get_data_source(target)
+  if not data_source:
+    return amount
+  var shield: float = data_source.get_stat(target, "shield")
   if shield == null or shield <= 0:
     return amount
-  Stats.set_stat(entity, "shield_regen_timer", 0.0)
+  data_source.set_stat(target, "shield_regen_timer", 0.0)
   var absorbed: float = min(amount, shield)
   shield -= absorbed
-  Stats.set_stat(entity, "shield", shield)
-  var max_shield: float = Stats.get_stat(entity, "max_shield")
+  data_source.set_shield(target, shield)
   if shield <= 0:
-    EventBus.shield_broken.emit(entity)
-  EventBus.shield_changed.emit(entity, shield, max_shield)
+    EventBus.shield_broken.emit(target)
   return amount - absorbed
 
+func _get_data_source(entity: Node) -> Node:
+  if entity.is_in_group("boss"):
+    return BossData
+  elif entity.is_in_group("enemies"):
+    return EnemyData
+  return null