75 lines
2.6 KiB
GDScript
75 lines
2.6 KiB
GDScript
extends Node
|
|
|
|
func _process(delta: float) -> void:
|
|
_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 = entities[entity]
|
|
if not data["alive"]:
|
|
continue
|
|
var max_shield: float = data["max_shield"]
|
|
if max_shield <= 0:
|
|
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
|