Added first cut of a damage engine project.

Author: dr-jam

Projects/damage-engine/.editorconfig

@@ -0,0 +1,4 @@
+root = true
+
+[*]
+charset = utf-8

Projects/damage-engine/.gitattributes

@@ -0,0 +1,2 @@
+# Normalize EOL for all files that Git considers text files.
+* text=auto eol=lf

Projects/damage-engine/.gitignore

@@ -0,0 +1,3 @@
+# Godot 4+ specific ignores
+.godot/
+/android/

Projects/damage-engine/icon.svg

@@ -0,0 +1,43 @@
+[remap]
+
+importer="texture"
+type="CompressedTexture2D"
+uid="uid://0wv8ltbjt58h"
+path="res://.godot/imported/icon.svg-218a8f2b3041327d8a5756f3a245f83b.ctex"
+metadata={
+"vram_texture": false
+}
+
+[deps]
+
+source_file="res://icon.svg"
+dest_files=["res://.godot/imported/icon.svg-218a8f2b3041327d8a5756f3a245f83b.ctex"]
+
+[params]
+
+compress/mode=0
+compress/high_quality=false
+compress/lossy_quality=0.7
+compress/uastc_level=0
+compress/rdo_quality_loss=0.0
+compress/hdr_compression=1
+compress/normal_map=0
+compress/channel_pack=0
+mipmaps/generate=false
+mipmaps/limit=-1
+roughness/mode=0
+roughness/src_normal=""
+process/channel_remap/red=0
+process/channel_remap/green=1
+process/channel_remap/blue=2
+process/channel_remap/alpha=3
+process/fix_alpha_border=true
+process/premult_alpha=false
+process/normal_map_invert_y=false
+process/hdr_as_srgb=false
+process/hdr_clamp_exposure=false
+process/size_limit=0
+detect_3d/compress_to=1
+svg/scale=1.0
+editor/scale_with_editor_scale=false
+editor/convert_colors_with_editor_theme=false

Projects/damage-engine/icon.svg.import

@@ -0,0 +1,20 @@
+; Engine configuration file.
+; It's best edited using the editor UI and not directly,
+; since the parameters that go here are not all obvious.
+;
+; Format:
+;   [section] ; section goes between []
+;   param=value ; assign values to parameters
+
+config_version=5
+
+[application]
+
+config/name="DamageEngine"
+run/main_scene="uid://dq6qe51f47vw"
+config/features=PackedStringArray("4.5", "Mobile")
+config/icon="res://icon.svg"
+
+[rendering]
+
+renderer/rendering_method="mobile"

Projects/damage-engine/project.godot

@@ -0,0 +1,54 @@
+class_name Combatant
+extends Node
+
+const FRONT := 0
+const BACK := 1
+
+@export var display_name := "Unit"
+@export var row := FRONT
+
+@export var base_stats: Stats
+@export var weapon: Equipment
+@export var armor: Equipment
+
+# Defender’s per-element tags: { Element.Type.FIRE: "weak"/"resist"/"immune"/"absorb"/"normal" }
+@export var element_resist: Dictionary = {}
+
+# Active status flags
+var status: Dictionary = {}
+
+func _ready():
+	if base_stats == null:
+		base_stats = Stats.new()
+	for k in StatusEffects.KEYS.keys():
+		status[k] = StatusEffects.KEYS[k]
+
+func total_stats() -> Stats:
+	var s := base_stats.copy()
+	if weapon:
+		for k in weapon.stat_bonus.keys():
+			var key = (k == "def") if "def" else k
+			s.set_stat(key, s.get_stat(key) + int(weapon.stat_bonus[k]))
+	if armor:
+		for k in armor.stat_bonus.keys():
+			var key = (k == "def") if "def" else k
+			s.set_stat(key, s.get_stat(key) + int(armor.stat_bonus[k]))
+	return s
+
+func weapon_elements() -> Array:
+	return Element.combine(weapon.elements) if weapon and weapon.elements.size() > 0 else []
+
+func is_long_range_weapon() -> bool:
+	return weapon != null and weapon.long_range
+
+func is_alive() -> bool:
+	return base_stats.hp > 0
+
+func take_damage(n: int) -> void:
+	base_stats.hp = max(0, base_stats.hp - n)
+
+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:
+	status[k] = v

Projects/damage-engine/scripts/combatant.gd

@@ -0,0 +1 @@
+uid://ca7gd72aggdqc

Projects/damage-engine/scripts/combatant.gd.uid

@@ -0,0 +1,112 @@
+# res://scripts/DamageEngine.gd
+extends Node
+class_name FF4DamageEngine
+
+# ---------- Inner result type ----------
+class CombatResult:
+	var amount: int
+	var crit: bool
+	var absorbed: bool
+	var elements: Array  # Array[Element.Type]
+
+	func _init(amount: int = 0, crit: bool = false, absorbed: bool = false, elements: Array = []):
+		self.amount = amount
+		self.crit = crit
+		self.absorbed = absorbed
+		self.elements = elements.duplicate()
+
+	func apply_to(defender: Combatant) -> void:
+		if absorbed:
+			defender.heal(abs(amount))
+		else:
+			defender.take_damage(max(1, amount))
+
+	func pretty_str() -> String:
+		return "{amount:%d, crit:%s, absorbed:%s, elements:%s}" % [amount, str(crit), str(absorbed), str(elements)]
+
+# ---------- Tunables ----------
+const CRIT_BASE := 0.03          # base crit chance (no LUK)
+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
+
+# 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
+
+# ---------- Helpers ----------
+static func _rand_range(a: float, b: float) -> float:
+	return a + randf() * (b - a)
+
+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:
+	return Element.vs_defender(attacker_elems, defender_resist)
+
+static func _row_mult(attacker: Combatant, defender: Combatant) -> float:
+	var m := 1.0
+	if attacker.row == Combatant.BACK and not attacker.is_long_range_weapon():
+		m *= BACKROW_OUT
+	if defender.row == Combatant.BACK:
+		m *= BACKROW_IN
+	return m
+
+# ---------- Physical damage ----------
+static func physical_damage(attacker: Combatant, defender: Combatant) -> CombatResult:
+	var A := attacker.total_stats()
+	var D := defender.total_stats()
+
+	var atk_term := A.atk + int(floor(A.strn / 2.0))
+	var def_term := D.def_ + int(floor(D.vit / 2.0))
+
+	var crit := _roll_crit(A.agi)
+	var def_factor : float = crit if 0.25 else 0.50
+	var base : int = max(1, atk_term - int(floor(def_term * def_factor)))
+
+	base = int(round(base * _rand_range(VARIANCE_LOW, VARIANCE_HIGH)))
+
+	if crit:
+		base = int(round(base * CRIT_MULT))
+
+	base = int(round(base * StatusEffects.physical_out_mult(attacker.status)))
+	base = int(round(base * StatusEffects.physical_in_mult(defender.status)))
+
+	base = int(round(base * _row_mult(attacker, defender)))
+
+	var elems := attacker.weapon_elements()
+	var em := _element_mult(elems, defender.element_resist)
+	base = int(round(base * em))
+	var absorbed := (em < 0.0)
+
+	if not absorbed:
+		base = max(1, base)
+
+	return CombatResult.new(base, crit, absorbed, elems)
+
+# ---------- Magical damage (single-element) ----------
+# Uses WIS for offense, WIL for resistance.
+static func magical_damage(attacker: Combatant, defender: Combatant, power: int, elem: Element.Type) -> CombatResult:
+	var A := attacker.total_stats()
+	var D := defender.total_stats()
+
+	var mag_term := power + int(floor(A.wis / 2.0)) + int(floor(A.mag / 2.0))
+	var mres := int(floor(D.mdef / 2.0) + floor(D.wil / 2.0))
+
+	var base : int = max(1, mag_term - mres)
+	base = int(round(base * _rand_range(VARIANCE_LOW, VARIANCE_HIGH)))
+	base = int(round(base * StatusEffects.magical_in_mult(defender.status)))
+
+	var em := _element_mult([elem], defender.element_resist)
+	base = int(round(base * em))
+	var absorbed := (em < 0.0)
+
+	if not absorbed:
+		base = max(1, base)
+
+	return CombatResult.new(base, false, absorbed, [elem])
+
+# ---------- Optional: keep a static applier for convenience ----------
+static func apply_result(defender: Combatant, result: CombatResult) -> void:
+	result.apply_to(defender)

Projects/damage-engine/scripts/damage_engine.gd

@@ -0,0 +1 @@
+uid://cl4heftt1h7ia