update

scripts/abilities/ability.gd

@@ -7,55 +7,68 @@ enum Type { SINGLE, AOE, UTILITY, ULT, PASSIVE }
 @export var type: Type = Type.SINGLE
 @export var damage: float = 0.0
 @export var ability_range: float = 3.0
+@export var cooldown: float = 0.0
+@export var uses_gcd: bool = true
 @export var icon: String = ""
 
-func execute(player: Node, targeting: Node) -> void:
+func execute(player: Node, targeting: Node) -> bool:
   var dmg: float = _get_modified_damage(player, damage)
   match type:
     Type.SINGLE:
-      _execute_single(player, targeting, dmg)
+      return _execute_single(player, targeting, dmg)
     Type.AOE:
-      _execute_aoe(player, dmg)
+      return _execute_aoe(player, dmg)
     Type.UTILITY:
-      _execute_utility(player)
+      return _execute_utility(player)
     Type.ULT:
-      _execute_ult(player, targeting, dmg)
+      return _execute_ult(player, targeting, dmg)
+  return false
 
 func _get_modified_damage(player: Node, base: float) -> float:
   var combat: Node = player.get_node("Combat")
   return combat.apply_passive(base)
 
-func _execute_single(player: Node, targeting: Node, dmg: float) -> void:
+func _in_range(player: Node, targeting: Node) -> bool:
+  if ability_range <= 0:
+    return true
   var target: Node3D = targeting.current_target
   if not target or not is_instance_valid(target):
-    return
+    return false
   var dist: float = player.global_position.distance_to(target.global_position)
-  if dist > ability_range:
-    return
+  return dist <= ability_range
+
+func _execute_single(player: Node, targeting: Node, dmg: float) -> bool:
+  if not _in_range(player, targeting):
+    return false
+  var target: Node3D = targeting.current_target
   EventBus.damage_requested.emit(player, target, dmg)
   EventBus.attack_executed.emit(player, player.global_position, -player.global_transform.basis.z, dmg)
+  return true
 
-func _execute_aoe(player: Node, dmg: float) -> void:
+func _execute_aoe(player: Node, dmg: float) -> bool:
+  var hit := false
   var enemies := player.get_tree().get_nodes_in_group("enemies")
   for enemy in enemies:
     var dist: float = player.global_position.distance_to(enemy.global_position)
     if dist <= ability_range:
       EventBus.damage_requested.emit(player, enemy, dmg)
-  EventBus.attack_executed.emit(player, player.global_position, -player.global_transform.basis.z, dmg)
+      hit = true
+  if hit:
+    EventBus.attack_executed.emit(player, player.global_position, -player.global_transform.basis.z, dmg)
+  return hit
 
-func _execute_utility(player: Node) -> void:
+func _execute_utility(player: Node) -> bool:
   var shield: Node = player.get_node_or_null("Shield")
   if shield:
     shield.current_shield = shield.max_shield
     EventBus.shield_changed.emit(player, shield.current_shield, shield.max_shield)
+    return true
+  return false
 
-func _execute_ult(player: Node, targeting: Node, dmg: float) -> void:
+func _execute_ult(player: Node, targeting: Node, dmg: float) -> bool:
+  if not _in_range(player, targeting):
+    return false
   var target: Node3D = targeting.current_target
-  if not target or not is_instance_valid(target):
-    return
-  var dist: float = player.global_position.distance_to(target.global_position)
-  if dist > ability_range:
-    return
   EventBus.damage_requested.emit(player, target, dmg * 4.0)
   var enemies := player.get_tree().get_nodes_in_group("enemies")
   for enemy in enemies:
@@ -64,3 +77,4 @@ func _execute_ult(player: Node, targeting: Node, dmg: float) -> void:
       if enemy_dist <= ability_range:
         EventBus.damage_requested.emit(player, enemy, dmg * 2.0)
   EventBus.attack_executed.emit(player, player.global_position, -player.global_transform.basis.z, dmg * 4.0)
+  return true