Class structure for the cards

Cards/CardBase.gd

@@ -18,78 +18,37 @@ class_name CardBase
 @export var damage_to_apply_to_caster: float = 0.0
 @export var status_to_apply_to_target: Array[StatusBase]
 @export var status_to_apply_to_caster: Array[StatusBase]
-@export var affect_all_targets: bool = false
-@export var affect_all_casters: bool = false
+# @export var affect_all_targets: bool = false
+# @export var affect_all_casters: bool = false
+# not needed since we use a list of targets, and the party can also be targets
 @export var amount_of_cards_to_draw: int = 0
 @export var amount_of_cards_to_discard: int = 0
 @export var application_type: Enums.ApplicationType = Enums.ApplicationType.ENEMY_ONLY
 @export var card_title: String = "NULL"
 @export var card_key_art: ImageTexture = null
 @export var card_description: String = "NULL"
 
+var card_effects_data: Array[EffectData] = []
 
-func can_play_card(caster: Entity, target: Entity) -> bool:
- if caster.get_party_component().can_play_on_entity(application_type, target):
- return true
- return false
-
-
-func on_card_play(caster: Entity, target: Entity) -> void:
- _deal_damage(caster, target)
- _apply_status(caster, target)
- _draw_cards()
- _discard_random_cards()
- # TODO add other functionality that lots of cards may share (eg: restore AP)
-
+func _ready() -> void:
+ card_effects_data = []
 
-# override in child cards if you want to deal damage in a unique way
-func _deal_damage(caster: Entity, target: Entity) -> void:
- # damage target
- if damage_to_apply_to_target != 0.0:
- _damage_entity(caster, target, damage_to_apply_to_target, affect_all_targets)
-
- #damage caster
- if damage_to_apply_to_caster != 0.0:
- _damage_entity(caster, caster, damage_to_apply_to_caster, affect_all_casters)
+# Need a parser of some sort to read a plainform card data and translate it to EffectData
+# This will call EffectData.add_effect_data() in a loop for every new effect
 
+@warning_ignore("unused_parameter")
+func parse_card_data(card_data: Dictionary) -> void:
+ # TODO
+ pass
 
-func _damage_entity(caster: Entity, target: Entity, damage_amount: float, damage_all: bool) -> void:
- var target_damage_data: DealDamageData = DealDamageData.new()
- target_damage_data.damage = damage_amount
- target_damage_data.caster = caster
-
- # If damage_all is set, try to damage all the party members set in the party component
- if damage_all:
- var party: Array[Entity] = target.get_party_component().party
- assert(party.size() > 0, "Entity has an empty party. Make sure you added party members.")
-
- for party_member: Entity in party:
- party_member.get_health_component().deal_damage(target_damage_data)
- else:
- target.get_health_component().deal_damage(target_damage_data)
+func _apply_all_effects() -> void:
+ for effect_data: EffectData in card_effects_data:
+ effect_data.apply_effect_data()
 
 
-func _apply_status(caster: Entity, target: Entity) -> void:
- # apply status to caster
- for status: StatusBase in status_to_apply_to_caster:
- if affect_all_casters:
- for party_member: Entity in caster.get_party_component().party:
- party_member.get_status_component().add_status(status, caster)
- else:
- caster.get_status_component().add_status(status, caster)
-
- # apply status to target
- for status: StatusBase in status_to_apply_to_target:
- if affect_all_targets:
- for party_member: Entity in target.get_party_component().party:
- party_member.get_status_component().add_status(status, caster)
- else:
- target.get_status_component().add_status(status, caster)
-
-
-func _draw_cards() -> void:
- CardManager.card_container.draw_cards(amount_of_cards_to_draw)
+func can_play_card(caster: Entity, target: Entity) -> bool:
+ return caster.get_party_component().can_play_on_entity(application_type, target)
 
 
-func _discard_random_cards() -> void:
- CardManager.card_container.discard_random_card(amount_of_cards_to_discard)
+func on_card_play() -> void:
+ _apply_all_effects()

Cards/Effects/EffectBase.gd

@@ -0,0 +1,10 @@
+# Base class for card effects
+class_name EffectBase extends Node
+
+@warning_ignore("unused_parameter")
+func apply_effect(caster: Entity, target: Entity, value: int) -> void:
+ pass
+
+# To be called by child classes through apply_effect. But since there might be multiple effects that need it, it's available in the parent class
+func _apply_status(status: StatusBase, caster: Entity, target: Entity) -> void:
+ target.get_status_component().add_status(status, caster)

Cards/Effects/EffectDamage.gd

@@ -0,0 +1,12 @@
+class_name EffectDamage extends EffectBase
+
+# @Override
+func apply_effect(caster: Entity, target: Entity, value: int) -> void:
+ var target_damage_data: DealDamageData = DealDamageData.new()
+ target_damage_data.damage = value
+ target_damage_data.caster = caster
+ target.get_health_component().deal_damage(target_damage_data)
+
+# TODO : what to do for Status that inflige damage over time ?
+ # Should they call an EffectDamage when they trigger each turn ?
+ # or should they directly call deal_damage on the target ?

Cards/Effects/EffectData.gd

@@ -0,0 +1,22 @@
+class_name EffectData extends Node
+
+# Effect data is a wrapper for the Effect class. It contains an effect, a caster, a target and a value (which will be applied by the effect)
+
+var effect: EffectBase = null
+var caster: Entity = null
+var list_targets: Array[Entity] = []
+var value: int = 0
+
+func _init(_effect: EffectBase, _caster: Entity, _list_targets: Array[Entity], _value: int) -> void:
+ self.effect = _effect
+ self.caster = _caster
+ self.list_targets = _list_targets
+ self.value = _value
+
+func add_effect_data(card: CardBase, _effect: EffectBase, _caster: Entity, _list_targets: Array[Entity], _value: int) -> void:
+ card.card_effects_data.append(EffectData.new(_effect, _caster, _list_targets, _value))
+
+func apply_effect_data() -> void:
+ # Help function to call more easily from the card point of view
+ for target: Entity in list_targets:
+ self.effect.apply_effect(self.caster, target, self.value)

Cards/Effects/EffectDiscardRandom.gd

@@ -0,0 +1,6 @@
+class_name EffectDiscardRandom extends EffectBase
+
+# @Override
+@warning_ignore("unused_parameter")
+func apply_effect(caster: Entity, target: Entity, value: int) -> void:
+ CardManager.card_container.discard_random_card(value)

Cards/Effects/EffectDraw.gd

@@ -0,0 +1,6 @@
+class_name EffectDraw extends EffectBase
+
+# @Override
+@warning_ignore("unused_parameter")
+func apply_effect(caster: Entity, target: Entity, value: int) -> void:
+ CardManager.card_container.draw_cards(value)

Cards/Effects/EffectPoison.gd

@@ -0,0 +1,8 @@
+class_name EffectPoison extends EffectBase
+
+# @Override
+func apply_effect(caster: Entity, target:Entity, value: int) -> void:
+ var debuff_poison: Debuff_Poison = Debuff_Poison.new() 
+ # if not instanciated, the debuff is not seen as a child of StatusBase
+ debuff_poison.status_turn_duration = value
+ _apply_status(debuff_poison, caster, target)

Cards/Resource/Card_Poison.tres

@@ -15,8 +15,6 @@ damage_to_apply_to_target = 0.0
 damage_to_apply_to_caster = 0.0
 status_to_apply_to_target = Array[Resource("res://Status/StatusBase.gd")]([SubResource("Resource_0h6wx")])
 status_to_apply_to_caster = Array[Resource("res://Status/StatusBase.gd")]([])
-affect_all_targets = false
-affect_all_casters = false
 amount_of_cards_to_draw = 0
 amount_of_cards_to_discard = 0
 application_type = 1

Core/Battler.gd

@@ -72,7 +72,7 @@ func _on_enemy_start_turn() -> void:
  assert(can_attack == true, "Enemy failed to attack.")
 
  if can_attack:
- enemy_attack.on_card_play(enemy, PlayerManager.player)
+ enemy_attack.on_card_play()
 
  # TODO: temporary delay so we can see the draw pile and discard pile working
  await get_tree().create_timer(enemy_attack_time).timeout
@@ -99,4 +99,4 @@ func _try_player_play_card_on_entity(entity: Entity) -> void:
  # remove queued card, then play the card
  # This is so the queued card doesn't have any influence over our hand count
  CardManager.card_container.remove_queued_card()
- queued_card_data.on_card_play(PlayerManager.player, entity)
+ queued_card_data.on_card_play()

Tests/test_cards.gd

@@ -6,7 +6,7 @@ var _battler_scene: PackedScene = load("res://Core/Battler.tscn")
 var _card_container_scene: PackedScene = load("res://Cards/CardContainer.tscn")
 var _battler: Battler = null
 var _card_container: CardContainer = null
-var _cards_in_hand: Array[CardWorld] = []
+# var _cards_in_hand: Array[CardWorld] = []
 
 
 func before_each():