refactor

systems/shield_system.gd

@@ -1,74 +1,39 @@
 extends Node
 
-func _process(delta: float) -> void:
-  _process_player(delta)
-  _process_entities(delta, EnemyData.entities)
-  _process_entities(delta, BossData.entities)
+func _ready() -> void:
+  if multiplayer.multiplayer_peer != null and not multiplayer.is_server() and not (multiplayer.multiplayer_peer is OfflineMultiplayerPeer):
+    set_physics_process(false)
+  else:
+    set_physics_process(true)
 
-func _process_player(delta: float) -> void:
-  if not PlayerData.alive or PlayerData.max_shield <= 0:
+var _regen_accum: float = 0.0
+
+func _physics_process(delta: float) -> void:
+  if not multiplayer.is_server() and multiplayer.multiplayer_peer != null:
     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:
+  _regen_accum += delta
+  if _regen_accum < 0.20:
+    return
+  var dt: float = _regen_accum
+  _regen_accum = 0.0
+  for entity in Stats.entities():
     if not is_instance_valid(entity):
       continue
-    var data: Dictionary = entities[entity]
-    if not data["alive"]:
+    var hp: float = float(Stats.get_stat(entity, "health", 0.0))
+    if hp <= 0.0:
       continue
-    var max_shield: float = data["max_shield"]
-    if max_shield <= 0:
+    var max_shield: float = float(Stats.get_stat(entity, "max_shield", 0.0))
+    if max_shield <= 0.0:
+      continue
+    var shield: float = float(Stats.get_stat(entity, "shield", 0.0))
+    var timer: float = float(Stats.get_stat(entity, "shield_regen_timer", 0.0))
+    if timer > 0.0:
+      Stats.set_stat(entity, "shield_regen_timer", max(0.0, timer - dt))
       continue
-    var shield: float = data["shield"]
     if shield < max_shield:
-      data["shield_regen_timer"] += delta
-      if data["shield_regen_timer"] >= data["shield_regen_delay"]:
-        var regen_rate: float = max_shield / data["shield_regen_time"]
-        shield += regen_rate * delta
-        if shield >= max_shield:
-          shield = max_shield
-          EventBus.shield_regenerated.emit(entity)
-        data["shield"] = shield
-        EventBus.shield_changed.emit(entity, shield, max_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
-  data_source.set_stat(target, "shield_regen_timer", 0.0)
-  var absorbed: float = min(amount, shield)
-  shield -= absorbed
-  data_source.set_shield(target, shield)
-  if shield <= 0:
-    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
+      var regen: float = float(Stats.get_stat(entity, "shield_regen", 0.0))
+      if regen <= 0.0:
+        regen = max_shield * 0.10
+      var new_shield: float = min(max_shield, shield + regen * dt)
+      Stats.set_stat(entity, "shield", new_shield)
+      EventBus.shield_changed.emit(entity, new_shield, max_shield)