Tightened up static typing and added more combat examples.

Author: dr-jam

Projects/damage-engine/scripts/combatant.gd

@@ -12,10 +12,10 @@ const BACK := 1
 @export var armor: Equipment
 
 # Defender’s per-element tags: { Element.Type.FIRE: "weak"/"resist"/"immune"/"absorb"/"normal" }
-@export var element_resist: Dictionary = {}
+@export var element_resist: Dictionary[Element.Type, String] = {}
 
 # Active status flags
-var status: Dictionary = {}
+var status: Dictionary[StatusEffects.Status, bool] = {}
 
 func _ready():
 	if base_stats == null:
@@ -35,7 +35,7 @@ func total_stats() -> Stats:
 			s.set_stat(k, s.get_stat(k) + int(armor.stat_bonus[k]))
 	return s
 
-func weapon_elements() -> Array:
+func weapon_elements() -> Array[Element.Type]:
 	if weapon and weapon.elements.size() > 0:
 		return Element.combine(weapon.elements)
 	else:
@@ -53,5 +53,5 @@ func take_damage(n: int) -> void:
 func heal(n: int) -> void:
 	base_stats.hp = min(base_stats.max_hp, base_stats.hp + n)
 
-func set_status_flag(k: String, v: bool) -> void:
+func set_status_flag(k: StatusEffects.Status, v: bool) -> void:
 	status[k] = v

Projects/damage-engine/scripts/damage_engine.gd

@@ -34,18 +34,18 @@ const CRIT_AGI_SCALE := 0.0015   # +0.15% crit per AGI
 const CRIT_MULT := 1.5
 const VARIANCE_LOW := 0.93
 const VARIANCE_HIGH := 1.07
-const DAMAGE_CAP := 9999       # maximum non-absorbed damage dealt
+const DAMAGE_CAP := 9999       
 
 # Hit/Evasion (physical only)
-const HIT_BASE := 0.90                 # base 90% hit chance
-const HIT_AGI_DIFF_SCALE := 0.003      # ±0.3% per AGI difference (attacker - defender)
-const HIT_MIN := 0.05                  # never below 5%
-const HIT_MAX := 0.99                  # never above 99%
+const HIT_BASE := 0.90                 
+const HIT_AGI_DIFF_SCALE := 0.003      
+const HIT_MIN := 0.05                  
+const HIT_MAX := 0.99                  
 const BLIND_HIT_MULT := 0.5            # blind halves hit chance
 
 # Rows (physical only)
-const BACKROW_OUT := 0.5   # attacker in back (non long-range) halves output
-const BACKROW_IN  := 0.5   # defender in back halves incoming
+const BACKROW_OUT := 0.5   
+const BACKROW_IN  := 0.5   
 
 # ---------- Helpers ----------
 static func _rand_range(a: float, b: float) -> float:
@@ -54,7 +54,7 @@ static func _rand_range(a: float, b: float) -> float:
 static func _roll_crit(agi: int) -> bool:
 	return randf() < (CRIT_BASE + float(agi) * CRIT_AGI_SCALE)
 
-static func _element_mult(attacker_elems: Array, defender_resist: Dictionary) -> float:
+static func _element_mult(attacker_elems: Array[Element.Type], defender_resist: Dictionary[Element.Type, String]) -> float:
 	return Element.vs_defender(attacker_elems, defender_resist)
 
 static func _row_mult(attacker: Combatant, defender: Combatant) -> float:
@@ -69,7 +69,7 @@ static func _roll_phys_hit(attacker: Combatant, defender: Combatant) -> bool:
 	var A := attacker.total_stats()
 	var D := defender.total_stats()
 	var chance := HIT_BASE + float(A.agi - D.agi) * HIT_AGI_DIFF_SCALE
-	if StatusEffects.has(attacker.status, "blind"):
+	if StatusEffects.has(attacker.status, StatusEffects.Status.BLIND):
 		chance *= BLIND_HIT_MULT
 	chance = clamp(chance, HIT_MIN, HIT_MAX)
 	return randf() < chance

Projects/damage-engine/scripts/damage_test.gd

@@ -4,6 +4,24 @@ extends Node2D
 @onready var hero: Combatant = $"../Hero"
 @onready var foe: Combatant  = $"../Enemy"
 
+func clear_status(u: Combatant) -> void:
+	for k in StatusEffects.KEYS.keys():
+		u.set_status_flag(k, false)
+
+func demo_phys(label: String) -> void:
+	var hp0 := foe.base_stats.hp
+	var r := FF4DamageEngine.physical_damage(hero, foe)
+	FF4DamageEngine.apply_result(foe, r)
+	print(label, " -> ", r.pretty_str(), " (Enemy HP ", hp0, " -> ", foe.base_stats.hp, ")")
+	foe.base_stats.hp = hp0
+
+func demo_mag(label: String, power: int, elem: Element.Type) -> void:
+	var hp0 := foe.base_stats.hp
+	var r := FF4DamageEngine.magical_damage(hero, foe, power, elem)
+	r.apply_to(foe)
+	print(label, " -> ", r.pretty_str(), " (Enemy HP ", hp0, " -> ", foe.base_stats.hp, ")")
+	foe.base_stats.hp = hp0
+
 func _ready():
 	randomize()
 	# Example enemy resistances
@@ -14,11 +32,44 @@ func _ready():
 		Element.Type.DARK: "absorb"
 	}
 
-	# Physical attack
-	var r1 : FF4DamageEngine.CombatResult = FF4DamageEngine.physical_damage(hero, foe)
-	FF4DamageEngine.apply_result(foe, r1)
-	print("Phys -> ", r1.pretty_str())
+	# Baseline (no statuses)
+	clear_status(hero)
+	clear_status(foe)
+	demo_phys("Phys baseline")
+	demo_mag("Fire baseline", 30, Element.Type.FIRE)
+
+	# Defender has Protect (physical incoming halved)
+	clear_status(hero)
+	clear_status(foe)
+	foe.set_status_flag(StatusEffects.Status.PROTECT, true)
+	demo_phys("Phys vs PROTECT")
+
+	# Defender is Defending (halves incoming physical)
+	clear_status(hero)
+	clear_status(foe)
+	foe.set_status_flag(StatusEffects.Status.DEFENDING, true)
+	demo_phys("Phys vs DEFENDING")
+
+	# Attacker is Berserk (physical output up)
+	clear_status(hero)
+	clear_status(foe)
+	hero.set_status_flag(StatusEffects.Status.BERSERK, true)
+	demo_phys("Phys with BERSERK")
+
+	# Attacker is Blind (physical output down and lower hit chance; may miss)
+	clear_status(hero)
+	clear_status(foe)
+	hero.set_status_flag(StatusEffects.Status.BLIND, true)
+	for i in 3:
+		demo_phys("Phys with BLIND (try %d)" % (i + 1))
+
+	# Defender has Shell (magical incoming halved)
+	clear_status(hero)
+	clear_status(foe)
+	foe.set_status_flag(StatusEffects.Status.SHELL, true)
+	demo_mag("Fire vs SHELL", 30, Element.Type.FIRE)
 
-	var r2: FF4DamageEngine.CombatResult = FF4DamageEngine.magical_damage(hero, foe, 30, Element.Type.FIRE)
-	r2.apply_to(foe)  # instance method also available
-	print("Fire -> ", r2.pretty_str())
+	# Magical absorb example (Dark is absorbed per resist table above)
+	clear_status(hero)
+	clear_status(foe)
+	demo_mag("Dark absorb", 30, Element.Type.DARK)

Projects/damage-engine/scripts/element.gd

@@ -17,14 +17,14 @@ const MULT := {
 	"absorb": -1.0
 }
 
-static func combine(elems: Array) -> Array:
-	var out: Array = []
+static func combine(elems: Array[Element.Type]) -> Array[Element.Type]:
+	var out: Array[Element.Type] = []
 	for e in elems:
 		if e != Type.NONE and not out.has(e):
 			out.append(e)
 	return out
 
-static func vs_defender(attacker_elems: Array, defender_resist: Dictionary) -> float:
+static func vs_defender(attacker_elems: Array[Element.Type], defender_resist: Dictionary[Element.Type, String]) -> float:
 	if attacker_elems.is_empty(): return 1.0
 	var m := 1.0
 	for e in attacker_elems:

Projects/damage-engine/scripts/equipment.gd

@@ -4,7 +4,7 @@ class_name Equipment
 @export var name: String = "Equipment"
 @export var long_range: bool = false                  # bows/whips ignore back-row penalty on attacker
 @export var elements: Array[Element.Type] = []        # applied on physical only (typical JRPG convention)
-@export var stat_bonus: Dictionary = {
+@export var stat_bonus: Dictionary[Stats.Stat, int] = {
 	Stats.Stat.STR: 0,
 	Stats.Stat.VIT: 0,
 	Stats.Stat.AGI: 0,

Projects/damage-engine/scripts/status_effects.gd

@@ -1,36 +1,35 @@
 class_name StatusEffects
 extends Resource
 
-
-# Boolean flags
-const KEYS := {
-	"defending": false, # Defend command (halves incoming)
-	"protect": false,   # Physical incoming halved
-	"shell": false,     # Magical incoming halved
-	"blind": false,     # We’ll model as physical output penalty
-	"berserk": false,   # Physical output bonus
-	"poison": false
+# Enumerated status flags
+enum Status { DEFENDING, PROTECT, SHELL, BLIND, BERSERK, POISON }
+
+# Default boolean flags keyed by Status enum
+const KEYS: Dictionary[Status, bool] = {
+	Status.DEFENDING: false, # Defend command (halves incoming)
+	Status.PROTECT: false,   # Physical incoming halved
+	Status.SHELL: false,     # Magical incoming halved
+	Status.BLIND: false,     # Physical output penalty, also affects hit chance
+	Status.BERSERK: false,   # Physical output bonus
+	Status.POISON: false
 }
 
-static func has(s: Dictionary, k: String) -> bool:
+static func has(s: Dictionary[Status, bool], k: Status) -> bool:
 	return bool(s.get(k, false))
 
-
-static func physical_out_mult(s: Dictionary) -> float:
+static func physical_out_mult(s: Dictionary[Status, bool]) -> float:
 	var m := 1.0
-	if has(s, "berserk"): m *= 1.5
-	if has(s, "blind"):   m *= 0.75
+	if has(s, Status.BERSERK): m *= 1.5
+	if has(s, Status.BLIND):   m *= 0.75
 	return m
 
-
-static func physical_in_mult(s: Dictionary) -> float:
+static func physical_in_mult(s: Dictionary[Status, bool]) -> float:
 	var m := 1.0
-	if has(s, "protect"):  m *= 0.5
-	if has(s, "defending"): m *= 0.5
+	if has(s, Status.PROTECT):   m *= 0.5
+	if has(s, Status.DEFENDING): m *= 0.5
 	return m
 
-
-static func magical_in_mult(s: Dictionary) -> float:
+static func magical_in_mult(s: Dictionary[Status, bool]) -> float:
 	var m := 1.0
-	if has(s, "shell"): m *= 0.5
+	if has(s, Status.SHELL): m *= 0.5
 	return m