allow one target per repair tool module

add tests for salvager range and cooldown
add collection rate for salvager modules and respect collection range of each of these modules
2026-06-02 22:24:40 +02:00 · 2026-06-02 21:39:05 +02:00 · 2026-06-02 21:28:31 +02:00 · 2026-06-01 23:05:21 +02:00 · 2026-05-27 17:03:13 +02:00
34 changed files with 1501 additions and 455 deletions
--- a/bin/app/data/config/modules.toml
+++ b/bin/app/data/config/modules.toml
@@ -34,7 +34,7 @@ threat_cost = 3.0
 fill_color = "#FF4040"
 glyph = "W"

-[module.combat]
+[module.weapon]
 multiplied_damage_formula = "1.0 + 0.15 * x"

 [[module]]
@@ -49,3 +49,47 @@ glyph = "E"

 [module.movement]
 added_speed_formula = "0.5 * x"
+
+[[module]]
+id = "laser_cannon"
+surface_mask = ["O"]
+materials = [{item = "iron_ingot", amount = 1}]
+player_production_level = 1
+production_time_seconds = 5
+threat_cost = 5.0
+fill_color = "#FF8040"
+glyph = "L"
+
+[module.weapon]
+damage_formula = "2"
+attack_range_formula = "5"
+attack_rate_formula = "2.0"
+
+[[module]]
+id = "salvage_bay_module"
+surface_mask = ["OO"]
+materials = [{item = "iron_ingot", amount = 2}]
+player_production_level = 1
+production_time_seconds = 5
+threat_cost = 0.0
+fill_color = "#AACC44"
+glyph = "Sv"
+
+[module.salvage]
+collection_range_formula = "50"
+cargo_capacity_formula = "10"
+collection_rate_formula = "0.5"
+
+[[module]]
+id = "repair_tool_module"
+surface_mask = ["O"]
+materials = [{item = "circuit_board", amount = 2}]
+player_production_level = 1
+production_time_seconds = 5
+threat_cost = 0.0
+fill_color = "#66CCFF"
+glyph = "Rp"
+
+[module.repair]
+repair_rate_formula = "5 + x"
+repair_range_formula = "80"
--- a/bin/app/data/config/ships.toml
+++ b/bin/app/data/config/ships.toml
@@ -2,6 +2,7 @@
 id = "fighter"
 available_from_start = true
 layout = ["XOX", "OOO", "XOX"]
+default_modules = [{type = "laser_cannon", x = 1, y = 1, rotation = "east"}]

 [ship.schematic]
 materials = [{item = "iron_ingot", amount = 3}, {item = "circuit_board", amount = 1}]
@@ -24,11 +25,6 @@ max_rotation_speed_formula  = "6.28"
 [ship.sensor]
 sensor_range_formula = "15"

-[ship.combat]
-damage_formula = "2"
-attack_range_formula = "5"
-attack_rate_formula = "2.0"
-
 [ship.loot]
 scrap_drop = 2

@@ -38,6 +34,7 @@ scrap_drop = 2
 id = "sniper"
 available_from_start = true
 layout = ["XOOX", "OOOO", "XOOX"]
+default_modules = [{type = "laser_cannon", x = 1, y = 1, rotation = "east"}]

 [ship.schematic]
 materials = [{item = "iron_ingot", amount = 3}, {item = "circuit_board", amount = 1}]
@@ -60,11 +57,6 @@ max_rotation_speed_formula  = "3.14"
 [ship.sensor]
 sensor_range_formula = "25"

-[ship.combat]
-damage_formula = "10"
-attack_range_formula = "20"
-attack_rate_formula = "0.5"
-
 [ship.loot]
 scrap_drop = 2

@@ -74,6 +66,7 @@ scrap_drop = 2
 id = "gunship"
 available_from_start = true
 layout = ["XOOOX", "OOOOO", "OOOOO", "XOOOX"]
+default_modules = [{type = "laser_cannon", x = 1, y = 1, rotation = "east"}]

 [ship.schematic]
 materials = [{item = "iron_ingot", amount = 3}, {item = "circuit_board", amount = 1}]
@@ -96,11 +89,6 @@ max_rotation_speed_formula  = "3.14"
 [ship.sensor]
 sensor_range_formula = "20"

-[ship.combat]
-damage_formula = "1"
-attack_range_formula = "10"
-attack_rate_formula = "5"
-
 [ship.loot]
 scrap_drop = 2

@@ -132,10 +120,6 @@ max_rotation_speed_formula  = "6.28"
 [ship.sensor]
 sensor_range_formula = "250"

-[ship.salvage]
-collection_range = 50
-cargo_capacity = 10
-
 [ship.loot]
 scrap_drop = 2

@@ -166,9 +150,5 @@ max_rotation_speed_formula  = "6.28"
 [ship.sensor]
 sensor_range_formula = "250"

-[ship.repair]
-repair_rate_formula = "5 + x"
-repair_range_formula = "80"
-
 [ship.loot]
 scrap_drop = 2
--- a/bin/app/data/config/visuals.toml
+++ b/bin/app/data/config/visuals.toml
@@ -141,26 +141,29 @@ outline = "#201a14"
 # -----------------------------------------------------------------------------
 # Ships
 #
-# Ships are drawn as oriented triangles/arrows. Color is keyed to role, not
-# schematic (architecture.md, "Layer Order").
+# Ships are drawn as oriented triangles/arrows. Color is keyed to schematic id.
 # -----------------------------------------------------------------------------

-[ships.player_combat]
+[ships.fighter]
 fill    = "#3366ff"
 outline = "#ffffff"

-[ships.salvage]
+[ships.sniper]
+fill    = "#3366ff"
+outline = "#ffffff"
+
+[ships.gunship]
+fill    = "#3366ff"
+outline = "#ffffff"
+
+[ships.salvage_ship]
 fill    = "#33cc66"
 outline = "#ffffff"

-[ships.repair]
+[ships.repair_ship]
 fill    = "#66ccff"
 outline = "#ffffff"

-[ships.enemy]
-fill    = "#cc3333"
-outline = "#ffffff"
-
 # -----------------------------------------------------------------------------
 # Laser beams (REQ-SHP-FIRING-BEAM)
 # -----------------------------------------------------------------------------
--- a/bin/balancing/data/balancing.toml
+++ b/bin/balancing/data/balancing.toml
@@ -12,8 +12,9 @@ enemy_buffer_width = 10
    level = 1
    count = 5
    modules = [
+      {type = "laser_cannon",  x = 1, y = 1, rotation = "east"},
      {type = "weapon_upgrade", x = 0, y = 1, rotation = "east"},
-      {type = "sensor_booster", x = 1, y = 0, rotation = "east"},
+      {type = "sensor_booster", x = 2, y = 1, rotation = "east"},
    ]

  [[arena.team]]
@@ -23,6 +24,7 @@ enemy_buffer_width = 10
    level = 1
    count = 1
    modules = [
+      {type = "laser_cannon",  x = 1, y = 1, rotation = "east"},
      {type = "armor_plate",   x = 1, y = 0, rotation = "east"},
      {type = "weapon_upgrade", x = 1, y = 2, rotation = "east"},
    ]
@@ -42,6 +44,7 @@ enemy_buffer_width = 10
    level = 1
    count = 1
    modules = [
+      {type = "laser_cannon",  x = 1, y = 1, rotation = "east"},
      {type = "armor_plate",    x = 1, y = 0, rotation = "east"},
      {type = "sensor_booster", x = 0, y = 1, rotation = "east"},
    ]
@@ -53,6 +56,7 @@ enemy_buffer_width = 10
    level = 1
    count = 1
    modules = [
+      {type = "laser_cannon",  x = 2, y = 1, rotation = "east"},
      {type = "armor_plate",    x = 1, y = 0, rotation = "east"},
      {type = "weapon_upgrade", x = 3, y = 1, rotation = "east"},
      {type = "engine_booster", x = 0, y = 1, rotation = "east"},
@@ -73,6 +77,7 @@ enemy_buffer_width = 10
    level = 1
    count = 1
    modules = [
+      {type = "laser_cannon",  x = 2, y = 2, rotation = "east"},
      {type = "armor_plate",    x = 1, y = 0, rotation = "east"},
      {type = "weapon_upgrade", x = 3, y = 2, rotation = "east"},
      {type = "engine_booster", x = 0, y = 1, rotation = "east"},
@@ -85,6 +90,7 @@ enemy_buffer_width = 10
    level = 1
    count = 5
    modules = [
+      {type = "laser_cannon",  x = 1, y = 1, rotation = "east"},
      {type = "engine_booster", x = 1, y = 0, rotation = "east"},
      {type = "sensor_booster", x = 2, y = 1, rotation = "east"},
    ]
@@ -104,7 +110,8 @@ enemy_buffer_width = 15
    level = 1
    count = 3
    modules = [
-      {type = "weapon_upgrade", x = 1, y = 1, rotation = "east"},
+      {type = "laser_cannon",   x = 1, y = 1, rotation = "east"},
+      {type = "weapon_upgrade", x = 2, y = 1, rotation = "east"},
      {type = "sensor_booster", x = 1, y = 0, rotation = "east"},
    ]
    [[arena.team.station]]
@@ -125,5 +132,6 @@ enemy_buffer_width = 15
    level = 1
    count = 8
    modules = [
+      {type = "laser_cannon",  x = 1, y = 1, rotation = "east"},
      {type = "engine_booster", x = 1, y = 0, rotation = "east"},
    ]
--- a/bin/test/data/config/modules.toml
+++ b/bin/test/data/config/modules.toml
@@ -34,5 +34,49 @@ threat_cost = 3.0
 fill_color = "#FF4040"
 glyph = "W"

-[module.combat]
+[module.weapon]
 multiplied_damage_formula = "1.2"
+
+[[module]]
+id = "laser_cannon"
+surface_mask = ["O"]
+materials = [{item = "iron_ingot", amount = 1}]
+player_production_level = 1
+production_time_seconds = 5
+threat_cost = 5.0
+fill_color = "#FF8040"
+glyph = "L"
+
+[module.weapon]
+damage_formula = "2"
+attack_range_formula = "5"
+attack_rate_formula = "2.0"
+
+[[module]]
+id = "salvage_bay_module"
+surface_mask = ["OO"]
+materials = [{item = "iron_ingot", amount = 2}]
+player_production_level = 1
+production_time_seconds = 5
+threat_cost = 0.0
+fill_color = "#AACC44"
+glyph = "Sv"
+
+[module.salvage]
+collection_range_formula = "50"
+cargo_capacity_formula = "10"
+collection_rate_formula = "0.5"
+
+[[module]]
+id = "repair_tool_module"
+surface_mask = ["O"]
+materials = [{item = "circuit_board", amount = 2}]
+player_production_level = 1
+production_time_seconds = 5
+threat_cost = 0.0
+fill_color = "#66CCFF"
+glyph = "Rp"
+
+[module.repair]
+repair_rate_formula = "5 + x"
+repair_range_formula = "80"
--- a/bin/test/data/config/ships.toml
+++ b/bin/test/data/config/ships.toml
@@ -2,6 +2,7 @@
 id = "interceptor"
 available_from_start = true
 layout = ["XOX", "OOO", "XOX"]
+default_modules = [{type = "laser_cannon", x = 1, y = 1, rotation = "east"}]

 [ship.schematic]
 materials = [{item = "iron_ingot", amount = 3}, {item = "circuit_board", amount = 1}]
@@ -24,11 +25,6 @@ max_rotation_speed_formula  = "100000"
 [ship.sensor]
 sensor_range_formula = "200"

-[ship.combat]
-damage_formula = "10 + 2*x"
-attack_range_formula = "150"
-attack_rate_formula = "2.0"
-
 [ship.loot]
 scrap_drop = 2

@@ -37,6 +33,7 @@ scrap_drop = 2
 id = "destroyer"
 available_from_start = true
 layout = ["XOOX", "OOOO", "XOOX"]
+default_modules = [{type = "laser_cannon", x = 1, y = 1, rotation = "east"}]

 [ship.schematic]
 materials = [{item = "iron_ingot", amount = 5}, {item = "circuit_board", amount = 2}]
@@ -59,11 +56,6 @@ max_rotation_speed_formula  = "100000"
 [ship.sensor]
 sensor_range_formula = "300"

-[ship.combat]
-damage_formula = "12 + 2*x"
-attack_range_formula = "250"
-attack_rate_formula = "1.0"
-
 [ship.loot]
 scrap_drop = 4

@@ -94,10 +86,6 @@ max_rotation_speed_formula  = "100000"
 [ship.sensor]
 sensor_range_formula = "250"

-[ship.salvage]
-collection_range = 50
-cargo_capacity = 10
-
 [ship.loot]
 scrap_drop = 2

@@ -128,9 +116,5 @@ max_rotation_speed_formula  = "100000"
 [ship.sensor]
 sensor_range_formula = "250"

-[ship.repair]
-repair_rate_formula = "5 + x"
-repair_range_formula = "80"
-
 [ship.loot]
 scrap_drop = 2
--- a/docs/requirements.md
+++ b/docs/requirements.md
@@ -7,10 +7,10 @@ Config files use the TOML format. The following config files drive game paramete
 - **world.toml** — world dimensions, region widths, expansion amounts, building refund percentage, wave timing, enemy ship level formula, belt speed, starting building blocks, departure interval.
 - **buildings.toml** — building block cost and construction time per building type.
 - **recipes.toml** — crafting recipes: inputs, outputs, quantities, durations, and reprocessing plant probabilities.
- **ships.toml** — per schematic: a human-readable display name (used in toasts and UI), ship stats (HP, max linear speed, damage, attack range, attack rate, sensor range, main acceleration, maneuvering acceleration, angular acceleration, max rotation speed) as formulas of ship level, required build materials, threat cost formula, player production level, whether the schematic is available from game start, and a layout grid defining the ship's module slots.
- **modules.toml** — per module type: id, surface mask, materials list, player production level, production time, threat cost, fill color, glyph, and stat modifier formulas (additive and/or multiplicative per stat).
+- **ships.toml** — per schematic: a human-readable display name (used in toasts and UI), hull stats (HP, max linear speed, sensor range, main acceleration, maneuvering acceleration, angular acceleration, max rotation speed) as formulas of ship level, required build materials, threat cost formula, player production level, whether the schematic is available from game start, a layout grid defining the ship's module slots, and a `default_modules` list used for enemy wave ships (see REQ-WAV-DEFAULT-MODULES).
+- **modules.toml** — per module type: id, surface mask, materials list, player production level, production time, threat cost, fill color, glyph, and an optional capability section and/or stat modifier formulas. A module with a capability section (`[module.weapon]`, `[module.salvage]`, or `[module.repair]`) containing base stat formulas is a **capability module** that grants the ship a weapon, salvage bay, or repair tool per instance (see REQ-MOD-CONFIG for the full list of formulas per capability type). A module with only `added_*`/`multiplied_*` formulas is a **passive module** that modifies stats on the ship or on capability module instances (see REQ-MOD-STAT-CALC).
 - **stations.toml** — HP, damage, range, fire rate, and scrap drop for player and enemy defence stations, defined as formulas of station level.
- **visuals.toml** — rendering-only config (not game parameters): fill and outline colors and glyphs for every building type, item type, ship role, and station type; beam color and width; overlay and toast colors. Loaded by the UI at startup; the simulation does not read it.
+- **visuals.toml** — rendering-only config (not game parameters): fill and outline colors and glyphs for every building type, item type, ship schematic, and station type; beam color and width; overlay and toast colors. Loaded by the UI at startup; the simulation does not read it.
 - **ship_layouts.toml** — named layout blueprints per ship type; written and read by the application to persist the layout blueprint panel (REQ-MOD-UI-BLUEPRINT-PANEL through REQ-MOD-UI-BLUEPRINT-FILE-LOAD). Not a game parameter file; the simulation does not read it.

 - REQ-CFG-RELOAD: When the player triggers a Restart (REQ-UI-GAME-MENU), all config files are reloaded from disk before the simulation is reset to its initial state. Formula strings are recompiled at that point. This allows config edits made while the application is running to take effect without a full application restart.
@@ -149,7 +149,7 @@ Modules in `modules.toml` define a `surface_mask` — a list of strings that des
 ## Ships

 - REQ-SHP-AUTONOMOUS: Ships are produced by shipyards and are fully autonomous once produced.
- REQ-SHP-STATS: Base ship stats are defined as formulas of ship level in `ships.toml`: HP (`[ship.health].hp_formula`), max linear speed (`[ship.movement].speed_formula`), damage (`[ship.combat].damage_formula`), attack range (`[ship.combat].attack_range_formula`), attack rate (`[ship.combat].attack_rate_formula`), sensor range (`[ship.sensors].range_formula`), main acceleration (`[ship.movement].main_acceleration_formula`, tiles/s²), maneuvering acceleration (`[ship.movement].maneuvering_acceleration_formula`, tiles/s²), angular acceleration (`[ship.movement].angular_acceleration_formula`, rad/s²), max rotation speed (`[ship.movement].max_rotation_speed_formula`, rad/s). Required build materials (`[ship.schematic].materials`) and availability from game start (`[[ship]].available_from_start`) are also defined there. Final ship stats incorporate module modifiers per REQ-MOD-STAT-CALC.
+- REQ-SHP-STATS: Base hull stats are defined as formulas of ship level in `ships.toml`: HP (`[ship.health].hp_formula`), max linear speed (`[ship.movement].speed_formula`), sensor range (`[ship.sensors].range_formula`), main acceleration (`[ship.movement].main_acceleration_formula`, tiles/s²), maneuvering acceleration (`[ship.movement].maneuvering_acceleration_formula`, tiles/s²), angular acceleration (`[ship.movement].angular_acceleration_formula`, rad/s²), max rotation speed (`[ship.movement].max_rotation_speed_formula`, rad/s). Required build materials (`[ship.schematic].materials`) and availability from game start (`[[ship]].available_from_start`) are also defined there. Combat, salvage, and repair capabilities are provided by modules (see REQ-MOD-CONFIG). Final hull stats incorporate passive module modifiers per REQ-MOD-STAT-CALC.
 - REQ-SHP-SPAWN-PLAYER: A ship produced by a shipyard spawns centered on the shipyard's output port tile.
 - REQ-SHP-SPAWN-ENEMY: Enemy ships spawn at a uniformly random position within the current enemy buffer zone — random X across the buffer's width and random Y across the world height.
 - REQ-SHP-MOVEMENT: Ships move using a physics-based model. Each ship has a velocity and a facing direction, both updated each tick. The main acceleration (`main_acceleration_formula`) is applied along the ship's current facing direction only. The maneuvering acceleration (`maneuvering_acceleration_formula`) can be applied in any direction independently of the facing direction, enabling lateral or braking movement without rotating. The angular acceleration (`angular_acceleration_formula`) controls how quickly the ship rotates. Linear speed is capped at the ship's `speed_formula` value; rotation rate is capped at the ship's `max_rotation_speed_formula` value. Ship position refers to the ship's center for all range, sensor, and attack checks.
@@ -157,13 +157,17 @@ Modules in `modules.toml` define a `surface_mask` — a list of strings that des
 - REQ-SHP-SENSOR: A ship perceives only entities within its sensor range. Behavior is driven by what is in sensor range; entities outside sensor range are ignored.
 - REQ-SHP-FIRING: All weapons — on ships and on defence stations — fire when off cooldown and the target is within attack range. Firing emits a fire event and starts a 0.15-second damage delay (half the beam duration). When that delay expires, damage is applied to the target — unless the target has already been destroyed, in which case the damage is silently dropped. If the shooter is destroyed before the delay expires, damage is still applied when the delay expires. There is no projectile entity and no intervening collision. The weapon's cooldown begins at the moment of firing, not at damage application.
 - REQ-SHP-FIRING-BEAM: Each fire event produces a visual laser beam drawn from the shooter's position to the target for 0.3 seconds. The beam endpoint is not the target's center but a point randomly offset from it: the offset direction is uniformly random and the offset magnitude is uniformly random up to half the target's visual size (for ships: half their rendered radius; for buildings/stations: half the shorter side of their tile footprint, in world units). The offset is chosen once per fire event and held fixed for the beam's lifetime. The beam is a pure rendering effect and has no simulation state (does not block movement, does not re-apply damage over its lifetime). Beams follow the shooter and target positions if either moves during the 0.3-second window. The beam is rendered for its full 0.3-second duration even if the shooter or target is destroyed before it expires.
- REQ-SHP-COMBAT: **Combat ships** (player) — engage enemy ships within sensor range. The player can configure the following per shipyard (applied to all ships produced by that shipyard):
+- REQ-SHP-COMBAT: Ships with at least one **weapon module** (player) — engage enemy ships within sensor range. The player can configure the following per shipyard (applied to all ships produced by that shipyard):
  - Stance: aggressive (advance toward enemies) / defensive (hold position near asteroid).
  - Target priority: closest / highest HP / structures first.
- REQ-SHP-RALLY: After spawning, aggressive-stance combat ships move to and loiter at the **rally point** — the midpoint between the two player defence stations (center of their Y-span, at the player defence stations' X position). While at the rally point, ships still engage any enemy that enters sensor range. Every `world.toml [world].departure_interval_seconds` seconds (default 20), all combat ships currently at the rally point depart simultaneously and begin their normal aggressive advance toward the enemy. The departure timer is global and shared across all shipyards; it is not reset by individual ship arrivals at the rally point.
- REQ-SHP-SALVAGE: **Salvage ships** (player) — patrol by moving forward (rightward, away from the asteroid) while searching sensor range. If scrap enters sensor range, move to it, collect, and deliver it to a Salvage Bay on the asteroid; after delivery, resume patrol. If an enemy ship enters sensor range while not currently targeting or carrying scrap, turn back (move toward the asteroid) until the enemy is no longer in sensor range, then resume patrol. Salvage ships are vulnerable to enemy ships while operating.
- REQ-SHP-REPAIR: **Repair ships** (player) — patrol by moving forward (rightward, away from the asteroid) while searching sensor range. If a damaged player defence station or player ship enters sensor range, move to it and repair. If an enemy ship enters sensor range while not currently repairing, turn back (move toward the asteroid) until the enemy is no longer in sensor range, then resume patrol. The player can configure the target priority per shipyard:
+- REQ-SHP-RALLY: After spawning, aggressive-stance ships with weapon modules move to and loiter at the **rally point** — the midpoint between the two player defence stations (center of their Y-span, at the player defence stations' X position). While at the rally point, ships still engage any enemy that enters sensor range. Every `world.toml [world].departure_interval_seconds` seconds (default 20), all ships with weapon modules currently at the rally point depart simultaneously and begin their normal aggressive advance toward the enemy. The departure timer is global and shared across all shipyards; it is not reset by individual ship arrivals at the rally point.
+- REQ-SHP-SALVAGE: Ships with at least one **salvage module** (player) — patrol by moving forward (rightward, away from the asteroid) while searching sensor range. If scrap enters sensor range, move to it; when it is within a module's `collection_range`, that module collects it (consuming the scrap entity). Once all cargo is full, fly to a Salvage Bay and deliver; after delivery, resume patrol. If an enemy ship enters sensor range while not currently targeting or carrying scrap, turn back (move toward the asteroid) until the enemy is no longer in sensor range, then resume patrol. Ships with salvage modules are vulnerable to enemy ships while operating.
+
+  Each salvage module instance operates independently: it has its own cargo hold (`cargo_capacity`), collection range (`collection_range`), and collection rate (`collection_rate`, in collections per second). After collecting a piece of scrap, the module cannot collect again until `1 / collection_rate` seconds have elapsed. A ship with multiple salvage modules can therefore collect multiple pieces of scrap per tick (one per ready module), and installs of different module types may have different ranges and rates. The ship navigates based on the maximum collection range across all installed salvage modules.
+- REQ-SHP-REPAIR: Ships with at least one **repair module** (player) — patrol by moving forward (rightward, away from the asteroid) while searching sensor range. If a damaged player defence station or player ship enters sensor range, move to it and repair. If an enemy ship enters sensor range while not currently repairing, turn back (move toward the asteroid) until the enemy is no longer in sensor range, then resume patrol. The player can configure the target priority per shipyard:
  - Defence stations first / ships first / nearest target.
+
+  Each repair module instance operates independently: it has its own repair rate (`repair_rate`) and repair range (`repair_range`). On each tick, a module first attempts to heal the ship's current behavior-level navigation target if that target is within the module's `repair_range` and is damaged (HP above zero and below maximum HP). If those conditions are not met — because the target is out of the module's `repair_range`, already at full health, or destroyed — the module independently searches for the nearest damaged friendly (player ship or player defence station) within its own `repair_range` and heals that instead. If no valid target is found within range, the module idles. A ship with multiple repair modules can therefore heal different targets simultaneously. Navigation is driven solely by the behavior-level target; individual module fallback targets do not affect which direction the ship moves.
 - REQ-SHP-ENEMY-AI: **Enemy ships** — engage the closest valid target (player defence station, HQ, or player ship) within their sensor range. If no target is in sensor range, they move toward the asteroid (leftward in world coordinates).
 - REQ-SHP-SCHEMATICS: The player selects a schematic per shipyard by clicking it. New schematics are unlocked automatically when an enemy defence station set is destroyed (REQ-DEF-SCHEMATIC-DROP) — there is no physical loot to collect.

@@ -175,12 +179,16 @@ Modules in `modules.toml` define a `surface_mask` — a list of strings that des
  - `id` — unique identifier, also used as the display name in the UI.
  - `surface_mask` — footprint within the ship layout grid (see Module Surface Mask Format).
  - `materials` — list of materials required per instance (added to the ship's build cost).
-  - `player_production_level` — fixed level for this module type; used as `x` in its stat modifier formulas.
+  - `player_production_level` — fixed level for this module type; used as `x` in its stat formulas.
  - `production_time_seconds` — time added to the ship's production cycle per instance.
  - `threat_cost` — threat cost added to the ship's threat cost per instance.
  - `fill_color` — fill color used to render this module's cells in the layout grid.
  - `glyph` — single character rendered on this module's cells in the layout grid and preview widget.
-  - Zero or more stat modifier formulas (see REQ-MOD-STAT-CALC).
+  - An optional **capability section** (`[module.weapon]`, `[module.salvage]`, or `[module.repair]`) containing base stat formulas. A module with base stat formulas is a capability module — each placed instance grants the ship an independent weapon, salvage bay, or repair tool with its own state (cooldown, target, cargo). A ship may have multiple capability module instances of the same or different types. Base stat formulas per capability type:
+    - **Weapon** (`[module.weapon]`): `damage_formula`, `attack_range_formula`, `attack_rate_formula`.
+    - **Salvage** (`[module.salvage]`): `collection_range_formula` (tiles), `cargo_capacity_formula` (integer scrap units), `collection_rate_formula` (collections per second).
+    - **Repair** (`[module.repair]`): `repair_rate_formula` (HP/s), `repair_range_formula` (tiles).
+  - Zero or more **passive stat modifier formulas** (`added_*`/`multiplied_*`) that boost stats on the ship hull or on capability module instances (see REQ-MOD-STAT-CALC). A single module may be both a capability module and provide passive modifiers.

 - REQ-MOD-LAYOUT: Each ship in `ships.toml` defines a `layout` — a list of strings representing the ship's module grid (see Ship Layout Format). All ships define a layout.

@@ -195,12 +203,18 @@ Modules in `modules.toml` define a `surface_mask` — a list of strings that des
 - REQ-MOD-MATERIALS: The total materials required to build a ship are the union of the ship's base `[ship.schematic].materials` and the `materials` of every module instance in the configured layout. Quantities of the same item type are summed.
 - REQ-MOD-PRODUCTION-TIME: The total production time is the ship's base `[ship.schematic].production_time_seconds` plus the sum of `production_time_seconds` for every module instance in the configured layout.
 - REQ-MOD-THREAT: The total threat cost of a ship is the ship's base `[ship.threat].cost_formula` evaluated at the ship's level, plus the sum of `threat_cost` for every module instance in the configured layout.
- REQ-MOD-STAT-CALC: For each ship stat, the final value is computed as: `final = base × total_multiplier + total_additive`, where:
-  - `base` is the ship's base stat formula evaluated at the ship's production level.
-  - `total_multiplier` = 1 + sum of (m_i − 1) for each multiplicative modifier m_i from all module instances. Each m_i is evaluated from the module's multiplicative formula at the module's `player_production_level`.
-  - `total_additive` = sum of all additive modifier values from all module instances. Each additive value is evaluated from the module's additive formula at the module's `player_production_level`.
+- REQ-MOD-STAT-CALC: For each stat (on the ship hull or on a capability module instance), the final value is computed as: `final = base × total_multiplier + total_additive`, where:
+  - `base` is the stat's base formula evaluated at the ship's production level (for hull stats) or at the capability module's `player_production_level` (for capability module stats).
+  - `total_multiplier` = 1 + sum of (m_i − 1) for each multiplicative modifier m_i from all passive module instances. Each m_i is evaluated from the module's multiplicative formula at the module's `player_production_level`.
+  - `total_additive` = sum of all additive modifier values from all passive module instances. Each additive value is evaluated from the module's additive formula at the module's `player_production_level`.

-  Module stat modifier formulas follow the naming convention: for a ship stat `ship.<category>.<stat>_formula`, a module may define `added_<stat>_formula` (additive) and/or `multiplied_<stat>_formula` (multiplicative) under `[module.<category>]`. Example: for `ship.sensor.sensor_range_formula`, a module may define `module.sensor.added_sensor_range_formula` and/or `module.sensor.multiplied_sensor_range_formula`.
+  Passive modifier formulas follow the naming convention: a module may define `added_<stat>_formula` (additive) and/or `multiplied_<stat>_formula` (multiplicative) under `[module.<category>]`. The category determines what the modifier targets:
+  - `[module.health]`, `[module.movement]`, `[module.sensor]` — modifiers apply to the ship hull's stats.
+  - `[module.weapon]` — modifiers apply to every weapon module instance on the ship.
+  - `[module.salvage]` — modifiers apply to every salvage module instance on the ship.
+  - `[module.repair]` — modifiers apply to every repair module instance on the ship.
+
+  Example: `[module.sensor].added_sensor_range_formula` adds to the ship's sensor range. `[module.weapon].multiplied_damage_formula` multiplies the damage of every weapon module instance on the ship.

 ### Module UI

@@ -244,7 +258,7 @@ Modules in `modules.toml` define a `surface_mask` — a list of strings that des
 - REQ-WAV-GAP: At game start and immediately after each wave is triggered, a random inter-wave gap is drawn uniformly from [`world.toml [waves].gap_min_seconds`, `gap_max_seconds`].
 - REQ-WAV-TRIGGER: When the gap expires, a wave is triggered. Ships are selected one at a time: from all schematics whose `threat.cost_formula` evaluates to > 0 at the current enemy ship level, uniformly randomly pick one whose cost fits the remaining threat budget. Repeat until no eligible schematic fits. Any remaining threat carries over to the next wave. A longer gap results in a larger wave. Because enemy ship level increases with time (REQ-WAV-SHIP-LEVEL), threat cost per ship rises naturally over the course of the game.
 - REQ-WAV-SHIP-LEVEL: Each wave's enemy ships are assigned a level determined by `world.toml [waves].ship_level_formula` where x is elapsed game time in seconds. This is the sole mechanism by which individual enemy ships become stronger over time. Wave *size* grows separately via threat accumulation (REQ-WAV-THREAT-RATE) and push scaling (REQ-PSH-ACCUMULATION). Per-ship stats and threat cost are computed from the ship level via the formulas in `ships.toml` (see REQ-SHP-STATS).
- REQ-WAV-NO-MODULES: Enemy ships spawned by waves have no modules. Their stats are computed from the base ship formulas only, with no module modifiers applied.
+- REQ-WAV-DEFAULT-MODULES: Enemy ships spawned by waves use the `default_modules` list defined per schematic in `ships.toml`. The `default_modules` array uses the same format as layout blueprints (see Layout Blueprint TOML Format). If `default_modules` is absent or empty, the ship spawns with no modules. Invalid module instances (unknown type, position outside the grid, position on a non-buildable cell, or overlapping another module) are silently skipped.
 - REQ-WAV-SPAWN-DURATION: Ships in a wave are spawned one at a time over `world.toml [waves].spawn_duration_seconds`.

 ## Push Scaling
@@ -304,7 +318,7 @@ The screen is divided into three vertical sections:

 ### Debug Draw

- REQ-UI-DEBUG-DRAW: A debug draw mode can be toggled on and off with the **M** key (REQ-UI-HOTKEYS). It is inactive by default. While active, the sensor range of every ship — both player and enemy — is drawn as a circle centered on the ship, using that ship role's outline color from `visuals.toml`.
+- REQ-UI-DEBUG-DRAW: A debug draw mode can be toggled on and off with the **M** key (REQ-UI-HOTKEYS). It is inactive by default. While active, the sensor range of every ship — both player and enemy — is drawn as a circle centered on the ship, using that ship schematic's outline color from `visuals.toml`.

 ### Escape Menu

--- a/modular_ships.md
+++ b/modular_ships.md
@@ -0,0 +1,87 @@
+# Modular Ships: Remove Ship Roles, Unify Capabilities as Modules
+
+## Why
+
+Ships currently have a fixed role (combat, salvage, repair) baked into their definition. This limits ship customization — a ship is either a fighter or a salvage ship, never both. By moving weapon, salvage cargo, and repair tool capabilities into the module system, players can freely compose ship loadouts. A single hull can carry two weapons and a repair tool, or a weapon and a salvage bay, etc.
+
+## What Changes
+
+### Ship definitions lose role-specific sections
+
+`ShipDef` drops `std::optional<ShipCombat>`, `std::optional<ShipSalvage>`, `std::optional<ShipRepair>`. Ships define only hull stats (HP, movement, sensor) and a layout grid. A new `default_modules` list is added per schematic for enemy wave ships (see below).
+
+### Capability modules replace roles
+
+New module types in `modules.toml` provide capabilities. A module with base stat formulas (e.g. `damage_formula`) under a capability section (`[module.weapon]`, `[module.salvage]`, `[module.repair]`) is a **capability module** that creates a child entity. A module with only `added_*`/`multiplied_*` formulas is a **passive module** that modifies stats.
+
+Example capability module:
+```toml
+[[module]]
+id = "laser_turret"
+[module.weapon]
+damage_formula = "5 + 2*x"       # x = module's player_production_level
+attack_range_formula = "8 + x"
+attack_rate_formula = "1.5 + 0.1*x"
+```
+
+Example passive module boosting weapons:
+```toml
+[[module]]
+id = "weapon_upgrade"
+[module.weapon]
+multiplied_damage_formula = "1.0 + 0.15 * x"
+```
+
+Example passive module boosting ship stats:
+```toml
+[[module]]
+id = "armor_plate"
+[module.health]
+multiplied_hp_formula = "1.0 + 0.2 * x"
+```
+
+### Capability modules become child entities
+
+Each placed capability module instance becomes its own entt entity with a `ModuleOwnerComponent { entt::entity ship }` linking it to the parent ship. This allows multiple instances of the same type (e.g. three weapons, each with independent stats, cooldown, and target).
+
+A new `ModuleOwnerComponent` is introduced:
+```cpp
+struct ModuleOwnerComponent
+{
+    entt::entity ship;
+};
+```
+
+### Passive modifiers apply to both ship and module entities
+
+During spawn, passive module modifiers are collected and routed by category:
+- `[module.health]`, `[module.movement]`, `[module.sensor]` modifiers apply to the ship entity's hull stats.
+- `[module.weapon]` modifiers apply to every weapon child entity on the ship.
+- `[module.repair]` modifiers apply to every repair child entity on the ship.
+- `[module.salvage]` modifiers apply to every salvage child entity on the ship.
+
+Capability module child entities must be created first, then passive modifiers are applied. The formula variable `x` is always the module's `player_production_level`.
+
+### Behavior components stay on the ship entity
+
+`ThreatResponseBehaviorComponent`, `SalvageBehaviorComponent`, `RepairBehaviorComponent` remain on the ship entity (they drive movement). They are attached if the ship has at least one module of the corresponding type.
+
+### Hybrid ships are allowed
+
+A ship may have modules of different capability types. Movement arbitration currently uses last-writer-wins (the last behavior system ticked sets the intent). This is acceptable for now; dynamic priority-based arbitration will be added later.
+
+### Systems query module entities
+
+Weapon, repair, and salvage tick systems query for their component + `ModuleOwnerComponent` and resolve position from the owner ship. Each module instance ticks independently.
+
+### Despawn cleans up child entities
+
+`ShipSystem::despawn` destroys the ship entity and all module entities whose `ModuleOwnerComponent::ship` matches it.
+
+### Enemy wave ships use default modules
+
+Since weapons are now modules, enemy ships need modules to fight. Each ship schematic in `ships.toml` defines a `default_modules` list (same format as layout blueprints). Wave-spawned enemy ships are instantiated with this module layout. If `default_modules` is absent or empty, the ship spawns with no modules (and therefore no combat/salvage/repair capability).
+
+### Visuals use per-schematic colors instead of per-role
+
+`visuals.toml` defines fill/outline colors and glyphs per ship schematic (e.g. fighter, sniper, gunship) rather than per role (combat, salvage, repair). Debug draw sensor circles use the schematic's outline color.
--- a/src/balancing/ArenaSimulation.cpp
+++ b/src/balancing/ArenaSimulation.cpp
@@ -14,6 +14,7 @@
 #include "EntityAdmin.h"
 #include "FactionComponent.h"
 #include "HealthComponent.h"
+#include "ModuleOwnerComponent.h"
 #include "MovementIntentSystem.h"
 #include "PositionComponent.h"
 #include "ScrapSystem.h"
@@ -159,7 +160,12 @@ void ArenaSimulation::placeStructures()
        }
        const entt::entity stationEntity = m_admin.spawnStation(
            anchor, parsed.footprint, absCells, hp, hp, isEnemy);
-        m_admin.addComponent<WeaponComponent>(stationEntity, weapon);
+        {
+            entt::entity wChild = m_admin.createModuleEntity();
+            m_admin.addComponent<WeaponComponent>(wChild, weapon);
+            m_admin.addComponent<ModuleOwnerComponent>(wChild,
+                ModuleOwnerComponent{stationEntity});
+        }
        m_buildingSystem->registerTileOccupancy(absCells, allocateBuildingId());
    };

@@ -247,6 +253,7 @@ void ArenaSimulation::tick()
    m_aiSystem->tickHomeReturnBehavior(m_admin);
    m_aiSystem->tickThreatResponseBehavior(m_admin, *m_buildingSystem);
    m_aiSystem->tickRepairBehavior(m_admin, *m_buildingSystem);
+    m_aiSystem->tickRepairTools(m_admin);
    m_aiSystem->tickSalvageBehavior(m_admin, *m_scrapSystem, *m_buildingSystem);

    // Combat resolution (tick step 8).
@@ -320,6 +327,15 @@ void ArenaSimulation::tickDeaths()
    {
        const StationBodyComponent& sb = m_admin.get<StationBodyComponent>(deadEntity);
        m_buildingSystem->unregisterTileOccupancy(sb.bodyCells);
+        {
+            std::vector<entt::entity> stationChildren;
+            m_admin.forEach<ModuleOwnerComponent>(
+                [&](entt::entity ce, const ModuleOwnerComponent& o)
+                {
+                    if (o.owner == deadEntity) { stationChildren.push_back(ce); }
+                });
+            for (entt::entity ce : stationChildren) { m_admin.destroy(ce); }
+        }
        m_admin.destroy(deadEntity);
    }

--- a/src/balancing/ArenaView.cpp
+++ b/src/balancing/ArenaView.cpp
@@ -14,23 +14,12 @@
 #include "FactionComponent.h"
 #include "HealthComponent.h"
 #include "PositionComponent.h"
-#include "RepairToolComponent.h"
-#include "SalvageCargoComponent.h"
 #include "ScrapSystem.h"
 #include "ShipIdentityComponent.h"
 #include "StationBodyComponent.h"

 namespace
 {
-
-ShipRole shipRoleFromComponents(bool isEnemy, bool hasCargo, bool hasRepairTool)
-{
-    if (isEnemy)       { return ShipRole::Enemy; }
-    if (hasCargo)      { return ShipRole::Salvage; }
-    if (hasRepairTool) { return ShipRole::Repair; }
-    return ShipRole::PlayerCombat;
-}
-
 }  // namespace


@@ -322,15 +311,12 @@ void ArenaView::drawShips(QPainter& painter)
 {
    m_sim->admin().forEach<ShipIdentityComponent, PositionComponent, FacingComponent,
                           FactionComponent>(
-        [&](entt::entity e, const ShipIdentityComponent& /*si*/,
+        [&](entt::entity /*e*/, const ShipIdentityComponent& si,
            const PositionComponent& pos, const FacingComponent& facing,
-            const FactionComponent& fac)
+            const FactionComponent& /*fac*/)
        {
-            const bool hasCargo  = m_sim->admin().hasAll<SalvageCargoComponent>(e);
-            const bool hasRepair = m_sim->admin().hasAll<RepairToolComponent>(e);
-            const ShipRole role  = shipRoleFromComponents(fac.isEnemy, hasCargo, hasRepair);
-            const std::map<ShipRole, ShipVisuals>::const_iterator it =
-                m_visuals->ships.find(role);
+            const std::map<std::string, ShipVisuals>::const_iterator it =
+                m_visuals->ships.find(si.schematicId);
            if (it == m_visuals->ships.end()) { return; }

            const QPointF center = worldToWidget(pos.value);
--- a/src/lib/config/ConfigLoader.cpp
+++ b/src/lib/config/ConfigLoader.cpp
@@ -7,8 +7,13 @@
 #include <utility>
 #include <vector>

+#include <QPoint>
+
 #include "toml.hpp"

+#include "Rotation.h"
+#include "ShipLayout.h"
+
 namespace
 {

@@ -207,6 +212,42 @@ toml::table parseFile(const std::string& path, const std::string& file)
    }
 }

+Rotation parseRotationString(const std::string& s)
+{
+    if (s == "east")  { return Rotation::East;  }
+    if (s == "south") { return Rotation::South; }
+    if (s == "west")  { return Rotation::West;  }
+    return Rotation::North;
+}
+
+std::vector<PlacedModule> parsePlacedModules(const toml::array& arr,
+                                             const std::string& file,
+                                             const std::string& path)
+{
+    std::vector<PlacedModule> result;
+    result.reserve(arr.size());
+    for (std::size_t i = 0; i < arr.size(); ++i)
+    {
+        const std::string elemPath = path + "[" + std::to_string(i) + "]";
+        const toml::table* t = arr[i].as_table();
+        if (t == nullptr) { continue; }
+        toml::table& mt = const_cast<toml::table&>(*t);
+
+        const std::optional<std::string> type = mt["type"].value<std::string>();
+        const std::optional<int64_t>     x    = mt["x"].value<int64_t>();
+        const std::optional<int64_t>     y    = mt["y"].value<int64_t>();
+        const std::optional<std::string> rot  = mt["rotation"].value<std::string>();
+        if (!type || !x || !y || !rot) { continue; }
+
+        PlacedModule pm;
+        pm.moduleId = *type;
+        pm.position = QPoint(static_cast<int>(*x), static_cast<int>(*y));
+        pm.rotation = parseRotationString(*rot);
+        result.push_back(std::move(pm));
+    }
+    return result;
+}
+
 }  // namespace


@@ -418,43 +459,13 @@ ShipsConfig ConfigLoader::loadShips(const std::string& path)
            def.loot.scrapDrop = static_cast<int>(requireInt(lMt["scrap_drop"], file, lPath + ".scrap_drop"));
        }

-        // Optional: combat
-        if (mt.contains("combat"))
+        // Optional: default_modules (REQ-WAV-DEFAULT-MODULES)
+        if (mt.contains("default_modules"))
        {
-            const std::string cPath = elemPath + ".combat";
-            const toml::table& cTable = requireTable(mt["combat"], file, cPath);
-            toml::table& cMt = const_cast<toml::table&>(cTable);
-            ShipCombat combat {
-                requireFormula(cMt["damage_formula"],       file, cPath + ".damage_formula"),
-                requireFormula(cMt["attack_range_formula"], file, cPath + ".attack_range_formula"),
-                requireFormula(cMt["attack_rate_formula"],  file, cPath + ".attack_rate_formula"),
-            };
-            def.combat = std::move(combat);
-        }
-
-        // Optional: salvage
-        if (mt.contains("salvage"))
-        {
-            const std::string sPath = elemPath + ".salvage";
-            const toml::table& sTable = requireTable(mt["salvage"], file, sPath);
-            toml::table& sMt = const_cast<toml::table&>(sTable);
-            ShipSalvage salvage;
-            salvage.collectionRange = requireDouble(sMt["collection_range"], file, sPath + ".collection_range");
-            salvage.cargoCapacity   = static_cast<int>(requireInt(sMt["cargo_capacity"], file, sPath + ".cargo_capacity"));
-            def.salvage = salvage;
-        }
-
-        // Optional: repair
-        if (mt.contains("repair"))
-        {
-            const std::string rPath = elemPath + ".repair";
-            const toml::table& rTable = requireTable(mt["repair"], file, rPath);
-            toml::table& rMt = const_cast<toml::table&>(rTable);
-            ShipRepair repair {
-                requireFormula(rMt["repair_rate_formula"],  file, rPath + ".repair_rate_formula"),
-                requireFormula(rMt["repair_range_formula"], file, rPath + ".repair_range_formula"),
-            };
-            def.repair = std::move(repair);
+            const toml::array& modArr = requireArray(mt["default_modules"], file,
+                elemPath + ".default_modules");
+            def.defaultModules = parsePlacedModules(modArr, file,
+                elemPath + ".default_modules");
        }

        cfg.ships.push_back(std::move(def));
@@ -514,9 +525,12 @@ static const StatEntry kKnownStats[] = {
    {"health",   "hp"},
    {"movement", "speed"},
    {"sensor",   "sensor_range"},
-    {"combat",   "damage"},
-    {"combat",   "attack_range"},
-    {"combat",   "attack_rate"},
+    {"weapon",   "damage"},
+    {"weapon",   "attack_range"},
+    {"weapon",   "attack_rate"},
+    {"salvage",  "collection_range"},
+    {"salvage",  "cargo_capacity"},
+    {"salvage",  "collection_rate"},
    {"repair",   "repair_rate"},
    {"repair",   "repair_range"},
 };
@@ -597,6 +611,63 @@ ModulesConfig ConfigLoader::loadModules(const std::string& path)
            }
        }

+        // Weapon capability section: [module.weapon] with base stat formulas
+        if (mt.contains("weapon"))
+        {
+            const std::string wPath = elemPath + ".weapon";
+            const toml::table& wTable = requireTable(mt["weapon"], file, wPath);
+            toml::table& wMt = const_cast<toml::table&>(wTable);
+            if (wMt.contains("damage_formula") || wMt.contains("attack_range_formula")
+                || wMt.contains("attack_rate_formula"))
+            {
+                ModuleWeaponCapability cap;
+                cap.damageFormula      = requireFormula(wMt["damage_formula"],
+                    file, wPath + ".damage_formula");
+                cap.attackRangeFormula = requireFormula(wMt["attack_range_formula"],
+                    file, wPath + ".attack_range_formula");
+                cap.attackRateFormula  = requireFormula(wMt["attack_rate_formula"],
+                    file, wPath + ".attack_rate_formula");
+                def.weaponCapability = std::move(cap);
+            }
+        }
+
+        // Salvage capability section: [module.salvage] with base stat formulas
+        if (mt.contains("salvage"))
+        {
+            const std::string sPath = elemPath + ".salvage";
+            const toml::table& sTable = requireTable(mt["salvage"], file, sPath);
+            toml::table& sMt = const_cast<toml::table&>(sTable);
+            if (sMt.contains("collection_range_formula") || sMt.contains("cargo_capacity_formula")
+                || sMt.contains("collection_rate_formula"))
+            {
+                ModuleSalvageCapability cap;
+                cap.collectionRangeFormula = requireFormula(sMt["collection_range_formula"],
+                    file, sPath + ".collection_range_formula");
+                cap.cargoCapacityFormula   = requireFormula(sMt["cargo_capacity_formula"],
+                    file, sPath + ".cargo_capacity_formula");
+                cap.collectionRateFormula  = requireFormula(sMt["collection_rate_formula"],
+                    file, sPath + ".collection_rate_formula");
+                def.salvageCapability = std::move(cap);
+            }
+        }
+
+        // Repair capability section: [module.repair] with base stat formulas
+        if (mt.contains("repair"))
+        {
+            const std::string rPath = elemPath + ".repair";
+            const toml::table& rTable = requireTable(mt["repair"], file, rPath);
+            toml::table& rMt = const_cast<toml::table&>(rTable);
+            if (rMt.contains("repair_rate_formula") || rMt.contains("repair_range_formula"))
+            {
+                ModuleRepairCapability cap;
+                cap.repairRateFormula  = requireFormula(rMt["repair_rate_formula"],
+                    file, rPath + ".repair_rate_formula");
+                cap.repairRangeFormula = requireFormula(rMt["repair_range_formula"],
+                    file, rPath + ".repair_range_formula");
+                def.repairCapability = std::move(cap);
+            }
+        }
+
        cfg.modules.push_back(std::move(def));
    }

--- a/src/lib/config/ModulesConfig.h
+++ b/src/lib/config/ModulesConfig.h
@@ -1,5 +1,6 @@
 #pragma once

+#include <optional>
 #include <string>
 #include <vector>

@@ -15,6 +16,27 @@ struct ModuleStatModifier
    Formula formula;
 };

+// Capability sections — present when the module grants that capability.
+struct ModuleWeaponCapability
+{
+    Formula damageFormula;
+    Formula attackRangeFormula;
+    Formula attackRateFormula;
+};
+
+struct ModuleSalvageCapability
+{
+    Formula collectionRangeFormula;
+    Formula cargoCapacityFormula;
+    Formula collectionRateFormula;
+};
+
+struct ModuleRepairCapability
+{
+    Formula repairRateFormula;
+    Formula repairRangeFormula;
+};
+
 struct ModuleDef
 {
    std::string id;
@@ -26,6 +48,10 @@ struct ModuleDef
    std::string fillColor;
    std::string glyph;
    std::vector<ModuleStatModifier> statModifiers;
+
+    std::optional<ModuleWeaponCapability>  weaponCapability;
+    std::optional<ModuleSalvageCapability> salvageCapability;
+    std::optional<ModuleRepairCapability>  repairCapability;
 };

 struct ModulesConfig
--- a/src/lib/config/ShipsConfig.h
+++ b/src/lib/config/ShipsConfig.h
@@ -1,11 +1,11 @@
 #pragma once

-#include <optional>
 #include <string>
 #include <vector>

 #include "Formula.h"
 #include "RecipesConfig.h"  // for RecipeIngredient
+#include "ShipLayout.h"     // for PlacedModule

 // Build materials and initial per-schematic production level
 // (REQ-BLD-SHIPYARD, REQ-DEF-SCHEMATIC-DROP).
@@ -42,27 +42,6 @@ struct ShipSensor
    Formula sensorRangeFormula;  // REQ-SHP-SENSOR, REQ-SHP-STATS
 };

-struct ShipCombat
-{
-    Formula damageFormula;
-    Formula attackRangeFormula;
-    Formula attackRateFormula;  // shots per second
-};
-
-// Optional; present only on salvage ships (REQ-SHP-SALVAGE).
-struct ShipSalvage
-{
-    double collectionRange;
-    int cargoCapacity;
-};
-
-// Optional; present only on repair ships (REQ-SHP-REPAIR).
-struct ShipRepair
-{
-    Formula repairRateFormula;
-    Formula repairRangeFormula;
-};
-
 // Scrap dropped on destruction (REQ-RES-SCRAP-DROP).
 struct ShipLoot
 {
@@ -82,12 +61,8 @@ struct ShipDef
    ShipSensor sensor;
    ShipLoot loot;

-    // Role-specific sections. A ship is a combat ship if combat is present,
-    // a salvage ship if salvage is present, etc. A ship may have multiple
-    // of these set (hybrid ships) once the behavior systems support it.
-    std::optional<ShipCombat> combat;
-    std::optional<ShipSalvage> salvage;
-    std::optional<ShipRepair> repair;
+    // Module layout used for enemy wave ships (REQ-WAV-DEFAULT-MODULES).
+    std::vector<PlacedModule> defaultModules;
 };

 struct ShipsConfig
--- a/src/lib/core/EntityAdmin.cpp
+++ b/src/lib/core/EntityAdmin.cpp
@@ -18,6 +18,11 @@ entt::entity EntityAdmin::createEntity()
    return m_registry.create();
 }

+entt::entity EntityAdmin::createModuleEntity()
+{
+    return m_registry.create();
+}
+
 bool EntityAdmin::isValid(entt::entity entity) const
 {
    return m_registry.valid(entity);
--- a/src/lib/core/EntityAdmin.h
+++ b/src/lib/core/EntityAdmin.h
@@ -66,6 +66,10 @@ public:

    entt::entity spawnHqProxy(QVector2D position, float hp, float maxHp);

+    // Creates a bare entity for module child entities (weapons, salvage, repair).
+    // Caller is responsible for attaching all required components.
+    entt::entity createModuleEntity();
+
 private:
    entt::entity createEntity();

--- a/src/lib/ecs/component/ModuleOwnerComponent.h
+++ b/src/lib/ecs/component/ModuleOwnerComponent.h
@@ -0,0 +1,9 @@
+#pragma once
+
+#include "entt/entity/entity.hpp"
+
+// Links a capability module child entity back to its owner ship or station.
+struct ModuleOwnerComponent
+{
+    entt::entity owner;
+};
--- a/src/lib/ecs/component/RepairBehaviorComponent.h
+++ b/src/lib/ecs/component/RepairBehaviorComponent.h
@@ -7,4 +7,5 @@
 struct RepairBehaviorComponent
 {
    std::optional<entt::entity> currentTarget;
+    float maxRepairRange = 0.0f;
 };
--- a/src/lib/ecs/component/SalvageBehaviorComponent.h
+++ b/src/lib/ecs/component/SalvageBehaviorComponent.h
@@ -9,5 +9,6 @@
 struct SalvageBehaviorComponent
 {
    std::optional<QVector2D> scrapTarget;
-    BuildingId deliveryBay;  // kInvalidBuildingId until assigned at a salvage bay
+    BuildingId deliveryBay;      // kInvalidBuildingId until assigned at a salvage bay
+    float maxCollectionRange = 0.0f;
 };
--- a/src/lib/ecs/component/SalvageCargoComponent.h
+++ b/src/lib/ecs/component/SalvageCargoComponent.h
@@ -5,4 +5,6 @@ struct SalvageCargoComponent
    int   capacity;
    int   current;
    float collectionRange;
+    int   collectionIntervalTicks;
+    int   cooldownTicksRemaining;
 };
--- a/src/lib/ecs/system/AiSystem.cpp
+++ b/src/lib/ecs/system/AiSystem.cpp
@@ -1,6 +1,7 @@
 #include "AiSystem.h"

 #include <optional>
+#include <unordered_map>
 #include <vector>

 #include <QVector2D>
@@ -14,6 +15,7 @@
 #include "HealthComponent.h"
 #include "HomeReturnBehaviorComponent.h"
 #include "HqProxyComponent.h"
+#include "ModuleOwnerComponent.h"
 #include "MovementIntentComponent.h"
 #include "PositionComponent.h"
 #include "RallyBehaviorComponent.h"
@@ -27,6 +29,43 @@
 #include "StationBodyComponent.h"
 #include "ThreatResponseBehaviorComponent.h"

+// ---------------------------------------------------------------------------
+// Shared helpers for repair targeting
+// ---------------------------------------------------------------------------
+
+struct RepairableInfo
+{
+    entt::entity entity;
+    QVector2D    position;
+    bool         isEnemy;
+    bool         isShip;
+    float        hp;
+    float        maxHp;
+};
+
+static std::vector<RepairableInfo> buildRepairables(EntityAdmin& admin)
+{
+    std::vector<RepairableInfo> repairables;
+
+    admin.forEach<ShipIdentityComponent, PositionComponent, FactionComponent, HealthComponent>(
+        [&repairables](entt::entity e, const ShipIdentityComponent& /*si*/,
+                       const PositionComponent& pos, const FactionComponent& f,
+                       const HealthComponent& h)
+        {
+            repairables.push_back({e, pos.value, f.isEnemy, true, h.hp, h.maxHp});
+        });
+
+    admin.forEach<StationBodyComponent, PositionComponent, FactionComponent, HealthComponent>(
+        [&repairables](entt::entity e, const StationBodyComponent& /*sb*/,
+                       const PositionComponent& pos, const FactionComponent& f,
+                       const HealthComponent& h)
+        {
+            repairables.push_back({e, pos.value, f.isEnemy, false, h.hp, h.maxHp});
+        });
+
+    return repairables;
+}
+
 // ---------------------------------------------------------------------------
 // tickHomeReturnBehavior  (priority 4)
 // ---------------------------------------------------------------------------
@@ -180,33 +219,7 @@ void AiSystem::tickThreatResponseBehavior(EntityAdmin& admin, const BuildingSyst

 void AiSystem::tickRepairBehavior(EntityAdmin& admin, BuildingSystem& buildings)
 {
-    // Snapshot all entities with health for repair targeting.
-    struct RepairableInfo
-    {
-        entt::entity entity;
-        QVector2D position;
-        bool isEnemy;
-        bool isShip;
-        float hp;
-        float maxHp;
-    };
-    std::vector<RepairableInfo> repairables;
-
-    admin.forEach<ShipIdentityComponent, PositionComponent, FactionComponent, HealthComponent>(
-        [&repairables](entt::entity e, const ShipIdentityComponent& /*si*/,
-                       const PositionComponent& pos, const FactionComponent& f,
-                       const HealthComponent& h)
-        {
-            repairables.push_back({e, pos.value, f.isEnemy, true, h.hp, h.maxHp});
-        });
-
-    admin.forEach<StationBodyComponent, PositionComponent, FactionComponent, HealthComponent>(
-        [&repairables](entt::entity e, const StationBodyComponent& /*sb*/,
-                       const PositionComponent& pos, const FactionComponent& f,
-                       const HealthComponent& h)
-        {
-            repairables.push_back({e, pos.value, f.isEnemy, false, h.hp, h.maxHp});
-        });
+    std::vector<RepairableInfo> repairables = buildRepairables(admin);

    // Snapshot enemy ships for threat detection.
    struct EnemyInfo
@@ -224,14 +237,12 @@ void AiSystem::tickRepairBehavior(EntityAdmin& admin, BuildingSystem& buildings)
            }
        });

-    admin.forEach<RepairBehaviorComponent, RepairToolComponent, PositionComponent,
+    admin.forEach<RepairBehaviorComponent, PositionComponent,
                  FactionComponent, SensorRangeComponent, MovementIntentComponent>(
-        [&](entt::entity e, RepairBehaviorComponent& rb, RepairToolComponent& rt,
+        [&](entt::entity e, RepairBehaviorComponent& rb,
            PositionComponent& pos, FactionComponent& /*faction*/,
            SensorRangeComponent& sensor, MovementIntentComponent& intent)
        {
-            const float repairRange = rt.range;
-
            // Flee if enemy nearby.
            bool enemyNearby = false;
            for (const EnemyInfo& enemy : enemies)
@@ -303,17 +314,6 @@ void AiSystem::tickRepairBehavior(EntityAdmin& admin, BuildingSystem& buildings)
                targetPos = admin.get<PositionComponent>(target).value;
            }

-            const float distToTarget = (targetPos - pos.value).length();
-            if (distToTarget <= repairRange)
-            {
-                if (admin.isValid(target) && admin.hasAll<HealthComponent>(target))
-                {
-                    HealthComponent& targetHealth = admin.get<HealthComponent>(target);
-                    targetHealth.hp = std::min(targetHealth.hp + rt.ratePerTick,
-                                               targetHealth.maxHp);
-                }
-            }
-
            if (2 > intent.priority)
            {
                intent = MovementIntentComponent{2, targetPos};
@@ -321,6 +321,67 @@ void AiSystem::tickRepairBehavior(EntityAdmin& admin, BuildingSystem& buildings)
        });
 }

+// ---------------------------------------------------------------------------
+// tickRepairTools
+// ---------------------------------------------------------------------------
+
+void AiSystem::tickRepairTools(EntityAdmin& admin)
+{
+    const std::vector<RepairableInfo> repairables = buildRepairables(admin);
+
+    admin.forEach<RepairToolComponent, ModuleOwnerComponent>(
+        [&](entt::entity /*e*/, RepairToolComponent& rt, const ModuleOwnerComponent& owner)
+        {
+            if (!admin.hasAll<RepairBehaviorComponent>(owner.owner)) { return; }
+
+            const RepairBehaviorComponent& rb =
+                admin.get<RepairBehaviorComponent>(owner.owner);
+            const PositionComponent& ownerPos =
+                admin.get<PositionComponent>(owner.owner);
+
+            // Try the ship's preferred nav target first.
+            if (rb.currentTarget)
+            {
+                const entt::entity preferred = *rb.currentTarget;
+                if (admin.isValid(preferred) && admin.hasAll<HealthComponent>(preferred)
+                    && admin.hasAll<PositionComponent>(preferred))
+                {
+                    HealthComponent& th = admin.get<HealthComponent>(preferred);
+                    const float dist =
+                        (admin.get<PositionComponent>(preferred).value
+                         - ownerPos.value).length();
+                    if (th.hp > 0.0f && th.hp < th.maxHp && dist <= rt.range)
+                    {
+                        rt.currentTarget = rb.currentTarget;
+                        th.hp = std::min(th.hp + rt.ratePerTick, th.maxHp);
+                        return;
+                    }
+                }
+            }
+
+            // Preferred target unavailable; scan for nearest damaged friendly in range.
+            rt.currentTarget = std::nullopt;
+            float bestDist = rt.range;
+            for (const RepairableInfo& r : repairables)
+            {
+                if (r.isEnemy) { continue; }
+                if (r.hp <= 0.0f || r.hp >= r.maxHp) { continue; }
+                const float dist = (r.position - ownerPos.value).length();
+                if (dist < bestDist)
+                {
+                    bestDist = dist;
+                    rt.currentTarget = r.entity;
+                }
+            }
+
+            if (!rt.currentTarget) { return; }
+
+            HealthComponent& targetHealth =
+                admin.get<HealthComponent>(*rt.currentTarget);
+            targetHealth.hp = std::min(targetHealth.hp + rt.ratePerTick, targetHealth.maxHp);
+        });
+}
+
 // ---------------------------------------------------------------------------
 // tickSalvageBehavior  (priority 1)
 // ---------------------------------------------------------------------------
@@ -344,15 +405,38 @@ void AiSystem::tickSalvageBehavior(EntityAdmin& admin, ScrapSystem& scraps,
            }
        });

+    // Aggregate cargo across all salvage-module children per owning ship.
+    struct AggregatedCargo
+    {
+        int totalCurrent  = 0;
+        int totalCapacity = 0;
+    };
+    std::unordered_map<entt::entity, AggregatedCargo> cargoByShip;
+    admin.forEach<SalvageCargoComponent, ModuleOwnerComponent>(
+        [&](entt::entity /*ce*/, const SalvageCargoComponent& c, const ModuleOwnerComponent& o)
+        {
+            AggregatedCargo& agg = cargoByShip[o.owner];
+            agg.totalCurrent  += c.current;
+            agg.totalCapacity += c.capacity;
+        });
+
    const std::vector<ScrapInfo> allScrap = scraps.allScrapInfo();

-    admin.forEach<SalvageBehaviorComponent, SalvageCargoComponent, PositionComponent,
+    // Tick down per-module collection cooldowns.
+    admin.forEach<SalvageCargoComponent>(
+        [](entt::entity /*e*/, SalvageCargoComponent& c)
+        {
+            if (c.cooldownTicksRemaining > 0) { --c.cooldownTicksRemaining; }
+        });
+
+    admin.forEach<SalvageBehaviorComponent, PositionComponent,
                  SensorRangeComponent, MovementIntentComponent>(
-        [&](entt::entity /*e*/, SalvageBehaviorComponent& salvageBehavior,
-            SalvageCargoComponent& cargo, PositionComponent& pos,
+        [&](entt::entity e, SalvageBehaviorComponent& salvageBehavior,
+            PositionComponent& pos,
            SensorRangeComponent& sensor, MovementIntentComponent& intent)
        {
-            const float collectRange = cargo.collectionRange;
+            const float collectRange = salvageBehavior.maxCollectionRange;
+            const AggregatedCargo& cargoState = cargoByShip[e];

            // Assign nearest SalvageBay if needed.
            if (salvageBehavior.deliveryBay == kInvalidBuildingId)
@@ -378,7 +462,8 @@ void AiSystem::tickSalvageBehavior(EntityAdmin& admin, ScrapSystem& scraps,
                }
            }

-            const bool cargoFull = (cargo.current >= cargo.capacity);
+            const bool cargoFull = (cargoState.totalCurrent >= cargoState.totalCapacity
+                                    && cargoState.totalCapacity > 0);

            if (cargoFull)
            {
@@ -389,17 +474,26 @@ void AiSystem::tickSalvageBehavior(EntityAdmin& admin, ScrapSystem& scraps,
                if (bayId != kInvalidBuildingId
                    && (pos.value - bayPos).length() <= 1.0f)
                {
-                    if (buildings.deliverScrapToSalvageBay(bayId))
-                    {
-                        --cargo.current;
-                    }
+                    // Decrement first non-empty salvage child.
+                    bool delivered = false;
+                    admin.forEach<SalvageCargoComponent, ModuleOwnerComponent>(
+                        [&](entt::entity /*ce*/, SalvageCargoComponent& c,
+                            const ModuleOwnerComponent& o)
+                        {
+                            if (delivered || o.owner != e || c.current <= 0) { return; }
+                            if (buildings.deliverScrapToSalvageBay(bayId))
+                            {
+                                --c.current;
+                                delivered = true;
+                            }
+                        });
                }
                return;
            }

            // Retreat if enemy near and cargo empty.
            bool retreating = false;
-            if (cargo.current == 0)
+            if (cargoState.totalCurrent == 0)
            {
                for (const EnemyShipPos& enemy : enemyShips)
                {
@@ -417,18 +511,32 @@ void AiSystem::tickSalvageBehavior(EntityAdmin& admin, ScrapSystem& scraps,
            }
            if (retreating) { return; }

-            // Collect nearby scrap.
-            for (const ScrapInfo& si : allScrap)
-            {
-                if ((si.position - pos.value).length() <= collectRange)
+            // Per-module independent collection: each ready module collects one scrap.
+            bool anythingCollected = false;
+            admin.forEach<SalvageCargoComponent, ModuleOwnerComponent>(
+                [&](entt::entity /*ce*/, SalvageCargoComponent& c,
+                    const ModuleOwnerComponent& o)
                {
-                    if (scraps.consume(si.entity))
+                    if (o.owner != e || c.current >= c.capacity
+                        || c.cooldownTicksRemaining > 0)
                    {
-                        ++cargo.current;
-                        salvageBehavior.scrapTarget = std::nullopt;
+                        return;
                    }
-                    break;
-                }
+                    for (const ScrapInfo& si : allScrap)
+                    {
+                        if ((si.position - pos.value).length() > c.collectionRange) { continue; }
+                        if (scraps.consume(si.entity))
+                        {
+                            ++c.current;
+                            c.cooldownTicksRemaining = c.collectionIntervalTicks;
+                            anythingCollected = true;
+                            break;
+                        }
+                    }
+                });
+            if (anythingCollected)
+            {
+                salvageBehavior.scrapTarget = std::nullopt;
            }

            // Move toward scrap target or find a new one.
--- a/src/lib/ecs/system/AiSystem.h
+++ b/src/lib/ecs/system/AiSystem.h
@@ -10,5 +10,6 @@ public:
    void tickHomeReturnBehavior(EntityAdmin& admin);
    void tickThreatResponseBehavior(EntityAdmin& admin, const BuildingSystem& buildings);
    void tickRepairBehavior(EntityAdmin& admin, BuildingSystem& buildings);
+    void tickRepairTools(EntityAdmin& admin);
    void tickSalvageBehavior(EntityAdmin& admin, ScrapSystem& scraps, BuildingSystem& buildings);
 };
--- a/src/lib/ecs/system/CombatSystem.cpp
+++ b/src/lib/ecs/system/CombatSystem.cpp
@@ -2,8 +2,8 @@

 #include "EntityAdmin.h"
 #include "FactionComponent.h"
-#include "StationBodyComponent.h"
 #include "HealthComponent.h"
+#include "ModuleOwnerComponent.h"
 #include "PositionComponent.h"
 #include "SensorRangeComponent.h"
 #include "ShipIdentityComponent.h"
@@ -22,24 +22,18 @@ void CombatSystem::tick(Tick currentTick,
                         BuildingSystem& /*buildings*/,
                         std::vector<FireEvent>& outFireEvents)
 {
-    // Ship weapons.
-    admin.forEach<WeaponComponent, ThreatResponseBehaviorComponent,
-                  PositionComponent, FactionComponent>(
-        [&](entt::entity e, WeaponComponent& weapon,
-            ThreatResponseBehaviorComponent& threatResponseBehavior,
-            PositionComponent& pos, FactionComponent& faction)
+    // All weapons (ships and stations) are child entities linked via ModuleOwnerComponent.
+    admin.forEach<WeaponComponent, ModuleOwnerComponent>(
+        [&](entt::entity /*e*/, WeaponComponent& weapon, const ModuleOwnerComponent& owner)
        {
-            weapon.currentTarget = threatResponseBehavior.currentTarget;
-            resolveWeapon(e, weapon, pos, faction, currentTick, admin, outFireEvents);
-        });
-
-    // Station weapons (entities with StationBodyComponent; ships are excluded because
-    // they lack that component and are already handled by the ship loop above).
-    admin.forEach<WeaponComponent, PositionComponent, FactionComponent, StationBodyComponent>(
-        [&](entt::entity e, WeaponComponent& weapon, PositionComponent& pos,
-            FactionComponent& faction, const StationBodyComponent& /*sb*/)
-        {
-            resolveWeapon(e, weapon, pos, faction, currentTick, admin, outFireEvents);
+            if (admin.hasAll<ThreatResponseBehaviorComponent>(owner.owner))
+            {
+                weapon.currentTarget =
+                    admin.get<ThreatResponseBehaviorComponent>(owner.owner).currentTarget;
+            }
+            const PositionComponent& pos     = admin.get<PositionComponent>(owner.owner);
+            const FactionComponent&  faction = admin.get<FactionComponent>(owner.owner);
+            resolveWeapon(owner.owner, weapon, pos, faction, currentTick, admin, outFireEvents);
        });
 }

--- a/src/lib/ecs/system/ShipSystem.cpp
+++ b/src/lib/ecs/system/ShipSystem.cpp
@@ -3,11 +3,13 @@
 #include <cassert>
 #include <map>
 #include <utility>
+#include <vector>

 #include "DynamicBodyComponent.h"
 #include "EntityAdmin.h"
 #include "FactionComponent.h"
 #include "HealthComponent.h"
+#include "ModuleOwnerComponent.h"
 #include "ModulesConfig.h"
 #include "MovementIntentComponent.h"
 #include "RallyBehaviorComponent.h"
@@ -85,17 +87,195 @@ entt::entity ShipSystem::spawn(const std::string& schematicId, int level,
        angularAccelPerTick, maxRotationSpeedPerTick, sensorRange,
        level, schematicId, isEnemy);

-    // Optional components based on ship role.
-    if (def->combat)
-    {
-        WeaponComponent w;
-        w.damage        = static_cast<float>(def->combat->damageFormula.evaluate(x));
-        w.range         = static_cast<float>(def->combat->attackRangeFormula.evaluate(x));
-        w.fireRateHz    = static_cast<float>(def->combat->attackRateFormula.evaluate(x));
-        w.cooldownTicks = 0.0f;
-        w.currentTarget = std::nullopt;
-        m_admin.addComponent<WeaponComponent>(entity, w);
+    // Determine module list: configured layout takes precedence over default.
+    const std::vector<PlacedModule>& modules =
+        layout.has_value() ? layout->placedModules : def->defaultModules;

+    // --- Pass 1: create capability child entities ----------------------------
+    std::vector<entt::entity> weaponChildren;
+    std::vector<entt::entity> salvageChildren;
+    std::vector<entt::entity> repairChildren;
+
+    for (const PlacedModule& pm : modules)
+    {
+        const ModuleDef* modDef = findModuleDef(pm.moduleId);
+        if (!modDef) { continue; }
+
+        const double mx = static_cast<double>(modDef->playerProductionLevel);
+
+        if (modDef->weaponCapability)
+        {
+            WeaponComponent w;
+            w.damage        = static_cast<float>(
+                modDef->weaponCapability->damageFormula.evaluate(mx));
+            w.range         = static_cast<float>(
+                modDef->weaponCapability->attackRangeFormula.evaluate(mx));
+            w.fireRateHz    = static_cast<float>(
+                modDef->weaponCapability->attackRateFormula.evaluate(mx));
+            w.cooldownTicks = 0.0f;
+            w.currentTarget = std::nullopt;
+
+            entt::entity child = m_admin.createModuleEntity();
+            m_admin.addComponent<WeaponComponent>(child, w);
+            m_admin.addComponent<ModuleOwnerComponent>(child, ModuleOwnerComponent{entity});
+            weaponChildren.push_back(child);
+        }
+
+        if (modDef->salvageCapability)
+        {
+            SalvageCargoComponent cargo;
+            cargo.capacity = static_cast<int>(
+                modDef->salvageCapability->cargoCapacityFormula.evaluate(mx));
+            cargo.current  = 0;
+            cargo.collectionRange = static_cast<float>(
+                modDef->salvageCapability->collectionRangeFormula.evaluate(mx));
+            const double rate = modDef->salvageCapability->collectionRateFormula.evaluate(mx);
+            cargo.collectionIntervalTicks = (rate > 0.0)
+                ? static_cast<int>(kTickRateHz / rate + 0.5)
+                : 0;
+            cargo.cooldownTicksRemaining = 0;
+
+            entt::entity child = m_admin.createModuleEntity();
+            m_admin.addComponent<SalvageCargoComponent>(child, cargo);
+            m_admin.addComponent<ModuleOwnerComponent>(child, ModuleOwnerComponent{entity});
+            salvageChildren.push_back(child);
+        }
+
+        if (modDef->repairCapability)
+        {
+            RepairToolComponent rt;
+            rt.ratePerTick   = static_cast<float>(
+                modDef->repairCapability->repairRateFormula.evaluate(mx))
+                / static_cast<float>(kTickRateHz);
+            rt.range         = static_cast<float>(
+                modDef->repairCapability->repairRangeFormula.evaluate(mx));
+            rt.currentTarget = std::nullopt;
+
+            entt::entity child = m_admin.createModuleEntity();
+            m_admin.addComponent<RepairToolComponent>(child, rt);
+            m_admin.addComponent<ModuleOwnerComponent>(child, ModuleOwnerComponent{entity});
+            repairChildren.push_back(child);
+        }
+    }
+
+    // --- Pass 2: apply passive stat modifiers --------------------------------
+
+    // Accumulate hull-level modifiers.
+    std::map<std::string, std::pair<double, double>> hullMods;
+    // Per-capability-type modifier accumulators (applied to each child).
+    std::map<std::string, std::pair<double, double>> weaponMods;
+    std::map<std::string, std::pair<double, double>> salvageMods;
+    std::map<std::string, std::pair<double, double>> repairMods;
+
+    for (const PlacedModule& pm : modules)
+    {
+        const ModuleDef* modDef = findModuleDef(pm.moduleId);
+        if (!modDef) { continue; }
+
+        const double mx = static_cast<double>(modDef->playerProductionLevel);
+
+        for (const ModuleStatModifier& sm : modDef->statModifiers)
+        {
+            const double val = sm.formula.evaluate(mx);
+
+            // Route modifier to the correct accumulator by stat category.
+            // weapon/salvage/repair stats go to the corresponding child map;
+            // hull stats (hp, speed, sensor_range, …) go to hullMods.
+            const bool isWeaponStat  = (sm.stat == "damage"
+                                     || sm.stat == "attack_range"
+                                     || sm.stat == "attack_rate");
+            const bool isSalvageStat = (sm.stat == "collection_range"
+                                     || sm.stat == "cargo_capacity");
+            const bool isRepairStat  = (sm.stat == "repair_rate"
+                                     || sm.stat == "repair_range");
+
+            std::map<std::string, std::pair<double, double>>* target = &hullMods;
+            if (isWeaponStat)  { target = &weaponMods;  }
+            if (isSalvageStat) { target = &salvageMods; }
+            if (isRepairStat)  { target = &repairMods;  }
+
+            std::pair<double, double>& acc = (*target)[sm.stat];
+            if (sm.modifierType == "multiplicative")
+            {
+                acc.first += (val - 1.0);
+            }
+            else
+            {
+                acc.second += val;
+            }
+        }
+    }
+
+    // Helper: apply a modifier map to a float stat.
+    auto applyMod = [](float& stat, const std::string& name,
+                       const std::map<std::string, std::pair<double, double>>& mods)
+    {
+        const auto it = mods.find(name);
+        if (it != mods.end())
+        {
+            stat = static_cast<float>(
+                static_cast<double>(stat) * (1.0 + it->second.first)
+                + it->second.second);
+        }
+    };
+
+    // Apply hull modifiers.
+    {
+        HealthComponent& health        = m_admin.get<HealthComponent>(entity);
+        DynamicBodyComponent& dynamics = m_admin.get<DynamicBodyComponent>(entity);
+        SensorRangeComponent& sensor   = m_admin.get<SensorRangeComponent>(entity);
+
+        applyMod(health.maxHp,                              "hp",                    hullMods);
+        health.hp = health.maxHp;
+        applyMod(dynamics.maxSpeedPerTick,                  "speed",                 hullMods);
+        applyMod(dynamics.mainAccelerationPerTick,          "main_acceleration",     hullMods);
+        applyMod(dynamics.maneuveringAccelerationPerTick,   "maneuvering_acceleration", hullMods);
+        applyMod(dynamics.angularAccelerationPerTick,       "angular_acceleration",  hullMods);
+        applyMod(dynamics.maxRotationSpeedPerTick,          "max_rotation_speed",    hullMods);
+        applyMod(sensor.value,                              "sensor_range",          hullMods);
+    }
+
+    // Apply weapon modifiers to each weapon child.
+    for (entt::entity child : weaponChildren)
+    {
+        WeaponComponent& w = m_admin.get<WeaponComponent>(child);
+        applyMod(w.damage,     "damage",       weaponMods);
+        applyMod(w.range,      "attack_range", weaponMods);
+        applyMod(w.fireRateHz, "attack_rate",  weaponMods);
+    }
+
+    // Apply salvage modifiers to each salvage child.
+    for (entt::entity child : salvageChildren)
+    {
+        SalvageCargoComponent& c = m_admin.get<SalvageCargoComponent>(child);
+        float fRange    = c.collectionRange;
+        float fCapacity = static_cast<float>(c.capacity);
+        // Apply rate modifier: compute rate from interval, apply multiplier, convert back.
+        float fRate = (c.collectionIntervalTicks > 0)
+            ? static_cast<float>(kTickRateHz) / static_cast<float>(c.collectionIntervalTicks)
+            : 0.0f;
+        applyMod(fRange,    "collection_range", salvageMods);
+        applyMod(fCapacity, "cargo_capacity",   salvageMods);
+        applyMod(fRate,     "collection_rate",  salvageMods);
+        c.collectionRange         = fRange;
+        c.capacity                = static_cast<int>(fCapacity + 0.5f);
+        c.collectionIntervalTicks = (fRate > 0.0f)
+            ? static_cast<int>(static_cast<float>(kTickRateHz) / fRate + 0.5f)
+            : 0;
+    }
+
+    // Apply repair modifiers to each repair child.
+    for (entt::entity child : repairChildren)
+    {
+        RepairToolComponent& rt = m_admin.get<RepairToolComponent>(child);
+        applyMod(rt.ratePerTick, "repair_rate",  repairMods);
+        applyMod(rt.range,       "repair_range", repairMods);
+    }
+
+    // --- Pass 3: attach behavior components based on capability presence -----
+
+    if (!weaponChildren.empty())
+    {
        m_admin.addComponent<ThreatResponseBehaviorComponent>(
            entity, ThreatResponseBehaviorComponent{});

@@ -106,95 +286,35 @@ entt::entity ShipSystem::spawn(const std::string& schematicId, int level,
        }
    }

-    if (def->salvage)
+    if (!salvageChildren.empty())
    {
-        SalvageCargoComponent cargo;
-        cargo.capacity        = def->salvage->cargoCapacity;
-        cargo.current         = 0;
-        cargo.collectionRange = static_cast<float>(def->salvage->collectionRange);
-        m_admin.addComponent<SalvageCargoComponent>(entity, cargo);
+        float maxCollRange = 0.0f;
+        for (entt::entity child : salvageChildren)
+        {
+            const float r = m_admin.get<SalvageCargoComponent>(child).collectionRange;
+            if (r > maxCollRange) { maxCollRange = r; }
+        }

-        SalvageBehaviorComponent salvageBehavior;
-        salvageBehavior.scrapTarget = std::nullopt;
-        salvageBehavior.deliveryBay = kInvalidBuildingId;
-        m_admin.addComponent<SalvageBehaviorComponent>(entity, salvageBehavior);
+        SalvageBehaviorComponent sb;
+        sb.scrapTarget        = std::nullopt;
+        sb.deliveryBay        = kInvalidBuildingId;
+        sb.maxCollectionRange = maxCollRange;
+        m_admin.addComponent<SalvageBehaviorComponent>(entity, sb);
    }

-    if (def->repair)
+    if (!repairChildren.empty())
    {
-        RepairToolComponent rt;
-        rt.ratePerTick    = static_cast<float>(def->repair->repairRateFormula.evaluate(x));
-        rt.range          = static_cast<float>(def->repair->repairRangeFormula.evaluate(x));
-        rt.currentTarget  = std::nullopt;
-        m_admin.addComponent<RepairToolComponent>(entity, rt);
-
-        m_admin.addComponent<RepairBehaviorComponent>(entity, RepairBehaviorComponent{});
-    }
-
-    // Apply module stat modifiers (REQ-MOD-STAT-CALC).
-    if (layout.has_value() && !layout->placedModules.empty())
-    {
-        std::map<std::string, std::pair<double, double>> mods;
-        for (const PlacedModule& pm : layout->placedModules)
+        float maxRepairRange = 0.0f;
+        for (entt::entity child : repairChildren)
        {
-            const ModuleDef* modDef = findModuleDef(pm.moduleId);
-            if (!modDef)
-            {
-                continue;
-            }
-            for (const ModuleStatModifier& sm : modDef->statModifiers)
-            {
-                const double val = sm.formula.evaluate(
-                    static_cast<double>(modDef->playerProductionLevel));
-                std::pair<double, double>& acc = mods[sm.stat];
-                if (sm.modifierType == "multiplicative")
-                {
-                    acc.first += (val - 1.0);
-                }
-                else
-                {
-                    acc.second += val;
-                }
-            }
+            const float r = m_admin.get<RepairToolComponent>(child).range;
+            if (r > maxRepairRange) { maxRepairRange = r; }
        }

-        auto applyMod = [&mods](float& stat, const std::string& name) {
-            const std::map<std::string, std::pair<double, double>>::const_iterator it =
-                mods.find(name);
-            if (it != mods.end())
-            {
-                stat = static_cast<float>(
-                    static_cast<double>(stat) * (1.0 + it->second.first)
-                    + it->second.second);
-            }
-        };
-
-        HealthComponent& health           = m_admin.get<HealthComponent>(entity);
-        DynamicBodyComponent& dynamics    = m_admin.get<DynamicBodyComponent>(entity);
-        SensorRangeComponent& sensor      = m_admin.get<SensorRangeComponent>(entity);
-
-        applyMod(health.maxHp, "hp");
-        health.hp = health.maxHp;
-        applyMod(dynamics.maxSpeedPerTick, "speed");
-        applyMod(dynamics.mainAccelerationPerTick, "main_acceleration");
-        applyMod(dynamics.maneuveringAccelerationPerTick, "maneuvering_acceleration");
-        applyMod(dynamics.angularAccelerationPerTick, "angular_acceleration");
-        applyMod(dynamics.maxRotationSpeedPerTick, "max_rotation_speed");
-        applyMod(sensor.value, "sensor_range");
-
-        if (m_admin.hasAll<WeaponComponent>(entity))
-        {
-            WeaponComponent& weapon = m_admin.get<WeaponComponent>(entity);
-            applyMod(weapon.damage, "damage");
-            applyMod(weapon.range, "attack_range");
-            applyMod(weapon.fireRateHz, "attack_rate");
-        }
-        if (m_admin.hasAll<RepairToolComponent>(entity))
-        {
-            RepairToolComponent& repairTool = m_admin.get<RepairToolComponent>(entity);
-            applyMod(repairTool.ratePerTick, "repair_rate");
-            applyMod(repairTool.range, "repair_range");
-        }
+        RepairBehaviorComponent rb;
+        rb.currentTarget  = std::nullopt;
+        rb.maxRepairRange = maxRepairRange;
+        m_admin.addComponent<RepairBehaviorComponent>(entity, rb);
    }

    return entity;
@@ -202,6 +322,13 @@ entt::entity ShipSystem::spawn(const std::string& schematicId, int level,

 void ShipSystem::despawn(entt::entity entity)
 {
+    std::vector<entt::entity> children;
+    m_admin.forEach<ModuleOwnerComponent>(
+        [&](entt::entity e, const ModuleOwnerComponent& o)
+        {
+            if (o.owner == entity) { children.push_back(e); }
+        });
+    for (entt::entity child : children) { m_admin.destroy(child); }
    m_admin.destroy(entity);
 }

--- a/src/lib/sim/Simulation.cpp
+++ b/src/lib/sim/Simulation.cpp
@@ -8,6 +8,7 @@
 #include "DynamicBodySystem.h"
 #include "FactionComponent.h"
 #include "HealthComponent.h"
+#include "ModuleOwnerComponent.h"
 #include "MovementIntentSystem.h"
 #include "PositionComponent.h"
 #include "ScrapSystem.h"
@@ -173,6 +174,7 @@ void Simulation::tick()
    m_aiSystem->tickHomeReturnBehavior(m_admin);                                          // priority 4
    m_aiSystem->tickThreatResponseBehavior(m_admin, *m_buildingSystem);                  // priority 3
    m_aiSystem->tickRepairBehavior(m_admin, *m_buildingSystem);                          // priority 2
+    m_aiSystem->tickRepairTools(m_admin);
    m_aiSystem->tickSalvageBehavior(m_admin, *m_scrapSystem, *m_buildingSystem);         // priority 1

    // Step 8: combat resolution
@@ -255,7 +257,12 @@ void Simulation::placeInitialStructures()
        }
        m_playerStation1Entity = m_admin.spawnStation(
            anchor, psParsed.footprint, absCells, psHp, psHp, false);
-        m_admin.addComponent<WeaponComponent>(m_playerStation1Entity, psWeapon);
+        {
+            entt::entity wChild = m_admin.createModuleEntity();
+            m_admin.addComponent<WeaponComponent>(wChild, psWeapon);
+            m_admin.addComponent<ModuleOwnerComponent>(wChild,
+                ModuleOwnerComponent{m_playerStation1Entity});
+        }
        m_buildingSystem->registerTileOccupancy(absCells, allocateBuildingId());
    }
    {
@@ -267,7 +274,12 @@ void Simulation::placeInitialStructures()
        }
        m_playerStation2Entity = m_admin.spawnStation(
            anchor, psParsed.footprint, absCells, psHp, psHp, false);
-        m_admin.addComponent<WeaponComponent>(m_playerStation2Entity, psWeapon);
+        {
+            entt::entity wChild = m_admin.createModuleEntity();
+            m_admin.addComponent<WeaponComponent>(wChild, psWeapon);
+            m_admin.addComponent<ModuleOwnerComponent>(wChild,
+                ModuleOwnerComponent{m_playerStation2Entity});
+        }
        m_buildingSystem->registerTileOccupancy(absCells, allocateBuildingId());
    }

@@ -316,7 +328,12 @@ void Simulation::placeEnemyStationSet(int generation)
        }
        m_currentEnemyStationEntities[0] = m_admin.spawnStation(
            anchor, esParsed.footprint, absCells, esHp, esHp, true);
-        m_admin.addComponent<WeaponComponent>(m_currentEnemyStationEntities[0], esWeapon);
+        {
+            entt::entity wChild = m_admin.createModuleEntity();
+            m_admin.addComponent<WeaponComponent>(wChild, esWeapon);
+            m_admin.addComponent<ModuleOwnerComponent>(wChild,
+                ModuleOwnerComponent{m_currentEnemyStationEntities[0]});
+        }
        m_buildingSystem->registerTileOccupancy(absCells, allocateBuildingId());
    }
    {
@@ -328,7 +345,12 @@ void Simulation::placeEnemyStationSet(int generation)
        }
        m_currentEnemyStationEntities[1] = m_admin.spawnStation(
            anchor, esParsed.footprint, absCells, esHp, esHp, true);
-        m_admin.addComponent<WeaponComponent>(m_currentEnemyStationEntities[1], esWeapon);
+        {
+            entt::entity wChild = m_admin.createModuleEntity();
+            m_admin.addComponent<WeaponComponent>(wChild, esWeapon);
+            m_admin.addComponent<ModuleOwnerComponent>(wChild,
+                ModuleOwnerComponent{m_currentEnemyStationEntities[1]});
+        }
        m_buildingSystem->registerTileOccupancy(absCells, allocateBuildingId());
    }
 }
@@ -407,6 +429,15 @@ void Simulation::tickDeathsAndLoot()
            m_scrapSystem->spawn(pos.value, scrap, despawnAt);
        }
        m_buildingSystem->unregisterTileOccupancy(sb.bodyCells);
+        {
+            std::vector<entt::entity> stationChildren;
+            m_admin.forEach<ModuleOwnerComponent>(
+                [&](entt::entity ce, const ModuleOwnerComponent& o)
+                {
+                    if (o.owner == deadEntity) { stationChildren.push_back(ce); }
+                });
+            for (entt::entity ce : stationChildren) { m_admin.destroy(ce); }
+        }
        m_admin.destroy(deadEntity);
    }

--- a/src/lib/sim/WaveSystem.cpp
+++ b/src/lib/sim/WaveSystem.cpp
@@ -34,7 +34,7 @@ void WaveSystem::tickWaveScheduler(Tick currentTick, ShipSystem& ships,
        if (currentTick >= entry.spawnAt)
        {
            ships.spawn(entry.schematicId, entry.level, entry.position,
-                        /*isEnemy=*/true);
+                        /*isEnemy=*/true, entry.layout);
        }
        else
        {
@@ -90,8 +90,9 @@ std::vector<WaveSystem::SpawnEntry> WaveSystem::composeWave(Tick currentTick,
    // Build eligible ship list with their costs at the current level.
    struct EligibleShip
    {
-        std::string schematicId;
-        double      cost;
+        std::string              schematicId;
+        double                   cost;
+        std::vector<PlacedModule> defaultModules;
    };
    std::vector<EligibleShip> eligible;
    for (const ShipDef& def : m_config.ships.ships)
@@ -100,8 +101,9 @@ std::vector<WaveSystem::SpawnEntry> WaveSystem::composeWave(Tick currentTick,
        if (cost > 0.0)
        {
            EligibleShip es;
-            es.schematicId = def.id;
-            es.cost        = cost;
+            es.schematicId    = def.id;
+            es.cost           = cost;
+            es.defaultModules = def.defaultModules;
            eligible.push_back(es);
        }
    }
@@ -151,11 +153,12 @@ std::vector<WaveSystem::SpawnEntry> WaveSystem::composeWave(Tick currentTick,
        budget -= chosen.cost;

        SpawnEntry entry;
-        entry.schematicId = chosen.schematicId;
-        entry.level       = shipLevel;
-        entry.spawnAt     = 0;  // set below after all picks are done
-        entry.position    = QVector2D(xDist(m_rng),
-                                      static_cast<float>(yDist(m_rng)) + 0.5f);
+        entry.schematicId              = chosen.schematicId;
+        entry.level                    = shipLevel;
+        entry.spawnAt                  = 0;  // set below after all picks are done
+        entry.position                 = QVector2D(xDist(m_rng),
+                                                   static_cast<float>(yDist(m_rng)) + 0.5f);
+        entry.layout.placedModules     = chosen.defaultModules;
        picked.push_back(entry);
    }

--- a/src/lib/sim/WaveSystem.h
+++ b/src/lib/sim/WaveSystem.h
@@ -7,6 +7,7 @@
 #include <QVector2D>

 #include "GameConfig.h"
+#include "ShipLayout.h"
 #include "Tick.h"

 class ShipSystem;
@@ -40,10 +41,11 @@ public:
 private:
    struct SpawnEntry
    {
-        std::string schematicId;
-        int         level;
-        Tick        spawnAt;
-        QVector2D   position;
+        std::string      schematicId;
+        int              level;
+        Tick             spawnAt;
+        QVector2D        position;
+        ShipLayoutConfig layout;
    };

    // Compose the next wave from the current threat budget, returning timed
--- a/src/test/BehaviorSystemTest.cpp
+++ b/src/test/BehaviorSystemTest.cpp
@@ -2,10 +2,13 @@

 #include <random>

+#include <QPoint>
 #include <QVector2D>

 #include "AiSystem.h"
 #include "BeltSystem.h"
+#include "ModuleOwnerComponent.h"
+#include "ShipLayout.h"
 #include "Building.h"
 #include "BuildingSystem.h"
 #include "BuildingType.h"
@@ -81,6 +84,7 @@ struct Fixture
        ai.tickHomeReturnBehavior(admin);
        ai.tickThreatResponseBehavior(admin, buildings);
        ai.tickRepairBehavior(admin, buildings);
+        ai.tickRepairTools(admin);
        ai.tickSalvageBehavior(admin, scraps, buildings);
        movementIntent.tick(admin);
        dynamicBody.tick(admin);
@@ -88,7 +92,67 @@ struct Fixture
    }
 };

+static ShipLayoutConfig makeSingleModuleLayout(const std::string& moduleId)
+{
+    PlacedModule pm;
+    pm.moduleId = moduleId;
+    pm.position = QPoint(1, 1);
+    pm.rotation = Rotation::East;
+    ShipLayoutConfig layout;
+    layout.placedModules.push_back(pm);
+    return layout;
+}
+
+static ShipLayoutConfig makeTwoModuleLayout(const std::string& moduleId)
+{
+    ShipLayoutConfig layout;
+    PlacedModule pm1;
+    pm1.moduleId = moduleId;
+    pm1.position = QPoint(0, 0);
+    pm1.rotation = Rotation::East;
+    layout.placedModules.push_back(pm1);
+    PlacedModule pm2;
+    pm2.moduleId = moduleId;
+    pm2.position = QPoint(0, 1);
+    pm2.rotation = Rotation::East;
+    layout.placedModules.push_back(pm2);
+    return layout;
+}
+
+static entt::entity firstSalvageChild(EntityAdmin& admin, entt::entity ship)
+{
+    entt::entity result = entt::null;
+    admin.forEach<SalvageCargoComponent, ModuleOwnerComponent>(
+        [&](entt::entity ce, const SalvageCargoComponent&, const ModuleOwnerComponent& o)
+        {
+            if (o.owner == ship && result == entt::null) { result = ce; }
+        });
+    return result;
+}
+
 // Helpers to read ECS data for a ship entity.
+static entt::entity firstRepairChild(EntityAdmin& admin, entt::entity ship)
+{
+    entt::entity result = entt::null;
+    admin.forEach<RepairToolComponent, ModuleOwnerComponent>(
+        [&](entt::entity ce, const RepairToolComponent&, const ModuleOwnerComponent& o)
+        {
+            if (o.owner == ship && result == entt::null) { result = ce; }
+        });
+    return result;
+}
+
+static std::vector<entt::entity> allRepairChildren(EntityAdmin& admin, entt::entity ship)
+{
+    std::vector<entt::entity> result;
+    admin.forEach<RepairToolComponent, ModuleOwnerComponent>(
+        [&](entt::entity ce, const RepairToolComponent&, const ModuleOwnerComponent& o)
+        {
+            if (o.owner == ship) { result.push_back(ce); }
+        });
+    return result;
+}
+
 static const MovementIntentComponent& intent(EntityAdmin& a, entt::entity e)
 {
    return a.get<MovementIntentComponent>(e);
@@ -299,7 +363,9 @@ TEST_CASE("BehaviorSystem: repair ship writes intent toward damaged friendly shi
          "[behavior]")
 {
    Fixture f;
-    const entt::entity repairShip = f.ships.spawn("repair_ship", 1, QVector2D(0.0f, 0.0f));
+    const ShipLayoutConfig repairLayout = makeSingleModuleLayout("repair_tool_module");
+    const entt::entity repairShip = f.ships.spawn("repair_ship", 1, QVector2D(0.0f, 0.0f),
+                                                   false, repairLayout);
    const entt::entity friendly   = f.ships.spawn("interceptor",  1, QVector2D(5.0f, 0.0f));

    f.admin.get<HealthComponent>(friendly).hp = f.admin.get<HealthComponent>(friendly).maxHp * 0.5f;
@@ -315,7 +381,9 @@ TEST_CASE("BehaviorSystem: repair ship heals damaged ally within repair range",
          "[behavior]")
 {
    Fixture f;
-    const entt::entity repairShip = f.ships.spawn("repair_ship", 1, QVector2D(0.0f, 0.0f));
+    const ShipLayoutConfig repairLayout = makeSingleModuleLayout("repair_tool_module");
+    const entt::entity repairShip = f.ships.spawn("repair_ship", 1, QVector2D(0.0f, 0.0f),
+                                                   false, repairLayout);
    const entt::entity friendly   = f.ships.spawn("interceptor",  1, QVector2D(1.0f, 0.0f));

    const float initialHp = f.admin.get<HealthComponent>(friendly).maxHp * 0.5f;
@@ -323,6 +391,7 @@ TEST_CASE("BehaviorSystem: repair ship heals damaged ally within repair range",

    f.ships.clearMovementIntents();
    f.ai.tickRepairBehavior(f.admin, f.buildings);
+    f.ai.tickRepairTools(f.admin);

    REQUIRE(health(f.admin, friendly).hp > initialHp);
 }
@@ -330,7 +399,8 @@ TEST_CASE("BehaviorSystem: repair ship heals damaged ally within repair range",
 TEST_CASE("BehaviorSystem: repair ship does not heal above maxHp", "[behavior]")
 {
    Fixture f;
-    f.ships.spawn("repair_ship", 1, QVector2D(0.0f, 0.0f));
+    const ShipLayoutConfig repairLayout = makeSingleModuleLayout("repair_tool_module");
+    f.ships.spawn("repair_ship", 1, QVector2D(0.0f, 0.0f), false, repairLayout);
    const entt::entity friendly = f.ships.spawn("interceptor",  1, QVector2D(1.0f, 0.0f));

    f.admin.get<HealthComponent>(friendly).hp = f.admin.get<HealthComponent>(friendly).maxHp - 0.001f;
@@ -339,6 +409,7 @@ TEST_CASE("BehaviorSystem: repair ship does not heal above maxHp", "[behavior]")
    {
        f.ships.clearMovementIntents();
        f.ai.tickRepairBehavior(f.admin, f.buildings);
+        f.ai.tickRepairTools(f.admin);
    }

    const HealthComponent& h = health(f.admin, friendly);
@@ -346,6 +417,210 @@ TEST_CASE("BehaviorSystem: repair ship does not heal above maxHp", "[behavior]")
    REQUIRE(h.hp == Approx(h.maxHp));
 }

+// ---------------------------------------------------------------------------
+// tickRepairTools — per-module targeting
+// ---------------------------------------------------------------------------
+
+TEST_CASE("BehaviorSystem: rt.currentTarget is set to preferred target when in range and damaged",
+          "[behavior]")
+{
+    Fixture f;
+    const ShipLayoutConfig repairLayout = makeSingleModuleLayout("repair_tool_module");
+    const entt::entity repairShip = f.ships.spawn("repair_ship", 1, QVector2D(0.0f, 0.0f),
+                                                   false, repairLayout);
+    const entt::entity friendly   = f.ships.spawn("interceptor",  1, QVector2D(10.0f, 0.0f));
+
+    f.admin.get<HealthComponent>(friendly).hp = f.admin.get<HealthComponent>(friendly).maxHp * 0.5f;
+
+    f.ships.clearMovementIntents();
+    f.ai.tickRepairBehavior(f.admin, f.buildings);
+    f.ai.tickRepairTools(f.admin);
+
+    const entt::entity rc = firstRepairChild(f.admin, repairShip);
+    REQUIRE(f.admin.isValid(rc));
+    REQUIRE(f.admin.get<RepairToolComponent>(rc).currentTarget.has_value());
+    REQUIRE(*f.admin.get<RepairToolComponent>(rc).currentTarget == friendly);
+    REQUIRE(health(f.admin, friendly).hp > f.admin.get<HealthComponent>(friendly).maxHp * 0.5f);
+}
+
+TEST_CASE("BehaviorSystem: repair module falls back to in-range target when preferred is out of repair range",
+          "[behavior]")
+{
+    Fixture f;
+    const ShipLayoutConfig repairLayout = makeSingleModuleLayout("repair_tool_module");
+    const entt::entity repairShip = f.ships.spawn("repair_ship", 1, QVector2D(0.0f, 0.0f),
+                                                   false, repairLayout);
+    // preferred: within sensor range (200) but beyond repair range (80)
+    const entt::entity preferred = f.ships.spawn("interceptor", 1, QVector2D(90.0f, 0.0f));
+    // fallback: within repair range
+    const entt::entity fallback  = f.ships.spawn("interceptor", 1, QVector2D(20.0f, 0.0f));
+
+    const float preferredInitHp = f.admin.get<HealthComponent>(preferred).maxHp * 0.5f;
+    const float fallbackInitHp  = f.admin.get<HealthComponent>(fallback).maxHp  * 0.5f;
+    f.admin.get<HealthComponent>(preferred).hp = preferredInitHp;
+    f.admin.get<HealthComponent>(fallback).hp  = fallbackInitHp;
+
+    // Force preferred as nav target without running full behavior tick.
+    f.admin.get<RepairBehaviorComponent>(repairShip).currentTarget = preferred;
+
+    f.ai.tickRepairTools(f.admin);
+
+    const entt::entity rc = firstRepairChild(f.admin, repairShip);
+    REQUIRE(f.admin.get<RepairToolComponent>(rc).currentTarget.has_value());
+    REQUIRE(*f.admin.get<RepairToolComponent>(rc).currentTarget == fallback);
+    REQUIRE(health(f.admin, fallback).hp   > fallbackInitHp);
+    REQUIRE(health(f.admin, preferred).hp == Approx(preferredInitHp));
+}
+
+TEST_CASE("BehaviorSystem: repair module falls back when preferred target is fully healed",
+          "[behavior]")
+{
+    Fixture f;
+    const ShipLayoutConfig repairLayout = makeSingleModuleLayout("repair_tool_module");
+    const entt::entity repairShip = f.ships.spawn("repair_ship", 1, QVector2D(0.0f, 0.0f),
+                                                   false, repairLayout);
+    const entt::entity preferred  = f.ships.spawn("interceptor", 1, QVector2D(10.0f, 0.0f));
+    const entt::entity fallback   = f.ships.spawn("interceptor", 1, QVector2D(15.0f, 0.0f));
+
+    // preferred is at full HP; only fallback needs repair
+    f.admin.get<HealthComponent>(preferred).hp = f.admin.get<HealthComponent>(preferred).maxHp;
+    const float fallbackInitHp = f.admin.get<HealthComponent>(fallback).maxHp * 0.5f;
+    f.admin.get<HealthComponent>(fallback).hp  = fallbackInitHp;
+
+    f.admin.get<RepairBehaviorComponent>(repairShip).currentTarget = preferred;
+
+    f.ai.tickRepairTools(f.admin);
+
+    const entt::entity rc = firstRepairChild(f.admin, repairShip);
+    REQUIRE(*f.admin.get<RepairToolComponent>(rc).currentTarget == fallback);
+    REQUIRE(health(f.admin, fallback).hp > fallbackInitHp);
+}
+
+TEST_CASE("BehaviorSystem: repair module falls back when preferred target is destroyed",
+          "[behavior]")
+{
+    Fixture f;
+    const ShipLayoutConfig repairLayout = makeSingleModuleLayout("repair_tool_module");
+    const entt::entity repairShip = f.ships.spawn("repair_ship", 1, QVector2D(0.0f, 0.0f),
+                                                   false, repairLayout);
+    const entt::entity preferred  = f.ships.spawn("interceptor", 1, QVector2D(10.0f, 0.0f));
+    const entt::entity fallback   = f.ships.spawn("interceptor", 1, QVector2D(15.0f, 0.0f));
+
+    const float fallbackInitHp = f.admin.get<HealthComponent>(fallback).maxHp * 0.5f;
+    f.admin.get<HealthComponent>(fallback).hp = fallbackInitHp;
+
+    f.admin.get<RepairBehaviorComponent>(repairShip).currentTarget = preferred;
+    f.ships.despawn(preferred);
+
+    f.ai.tickRepairTools(f.admin);
+
+    const entt::entity rc = firstRepairChild(f.admin, repairShip);
+    REQUIRE(*f.admin.get<RepairToolComponent>(rc).currentTarget == fallback);
+    REQUIRE(health(f.admin, fallback).hp > fallbackInitHp);
+}
+
+TEST_CASE("BehaviorSystem: rt.currentTarget is cleared when no repairable target is in range",
+          "[behavior]")
+{
+    Fixture f;
+    const ShipLayoutConfig repairLayout = makeSingleModuleLayout("repair_tool_module");
+    const entt::entity repairShip = f.ships.spawn("repair_ship", 1, QVector2D(0.0f, 0.0f),
+                                                   false, repairLayout);
+    // friendly is beyond repair range (80) but within sensor range (200)
+    const entt::entity outOfRange = f.ships.spawn("interceptor", 1, QVector2D(150.0f, 0.0f));
+
+    const float initHp = f.admin.get<HealthComponent>(outOfRange).maxHp * 0.5f;
+    f.admin.get<HealthComponent>(outOfRange).hp = initHp;
+
+    f.admin.get<RepairBehaviorComponent>(repairShip).currentTarget = outOfRange;
+
+    f.ai.tickRepairTools(f.admin);
+
+    const entt::entity rc = firstRepairChild(f.admin, repairShip);
+    REQUIRE_FALSE(f.admin.get<RepairToolComponent>(rc).currentTarget.has_value());
+    REQUIRE(health(f.admin, outOfRange).hp == Approx(initHp));
+}
+
+TEST_CASE("BehaviorSystem: two repair modules both heal preferred target additively",
+          "[behavior]")
+{
+    Fixture f;
+    const ShipLayoutConfig repairLayout = makeTwoModuleLayout("repair_tool_module");
+    const entt::entity repairShip = f.ships.spawn("repair_ship", 1, QVector2D(0.0f, 0.0f),
+                                                   false, repairLayout);
+    const entt::entity targetA    = f.ships.spawn("interceptor", 1, QVector2D(10.0f, 0.0f));
+
+    const float initHp = f.admin.get<HealthComponent>(targetA).maxHp * 0.5f;
+    f.admin.get<HealthComponent>(targetA).hp = initHp;
+
+    f.ships.clearMovementIntents();
+    f.ai.tickRepairBehavior(f.admin, f.buildings);
+    f.ai.tickRepairTools(f.admin);
+
+    // Both modules should have healed targetA — total increase is 2 * ratePerTick.
+    const float ratePerTick = (5.0f + 1.0f) / static_cast<float>(kTickRateHz);
+    REQUIRE(health(f.admin, targetA).hp == Approx(initHp + 2.0f * ratePerTick));
+
+    const std::vector<entt::entity> children = allRepairChildren(f.admin, repairShip);
+    REQUIRE(children.size() == 2);
+    for (const entt::entity child : children)
+    {
+        REQUIRE(f.admin.get<RepairToolComponent>(child).currentTarget == targetA);
+    }
+}
+
+TEST_CASE("BehaviorSystem: two repair modules both fall back and heal same target when preferred is fully healed",
+          "[behavior]")
+{
+    Fixture f;
+    const ShipLayoutConfig repairLayout = makeTwoModuleLayout("repair_tool_module");
+    const entt::entity repairShip = f.ships.spawn("repair_ship", 1, QVector2D(0.0f, 0.0f),
+                                                   false, repairLayout);
+    const entt::entity preferred  = f.ships.spawn("interceptor", 1, QVector2D(10.0f, 0.0f));
+    const entt::entity targetB    = f.ships.spawn("interceptor", 1, QVector2D(20.0f, 0.0f));
+
+    // preferred is at full HP so both modules must fall back
+    f.admin.get<HealthComponent>(preferred).hp = f.admin.get<HealthComponent>(preferred).maxHp;
+    const float initHp = f.admin.get<HealthComponent>(targetB).maxHp * 0.5f;
+    f.admin.get<HealthComponent>(targetB).hp = initHp;
+
+    f.admin.get<RepairBehaviorComponent>(repairShip).currentTarget = preferred;
+
+    f.ai.tickRepairTools(f.admin);
+
+    const float ratePerTick = (5.0f + 1.0f) / static_cast<float>(kTickRateHz);
+    REQUIRE(health(f.admin, targetB).hp == Approx(initHp + 2.0f * ratePerTick));
+
+    const std::vector<entt::entity> children = allRepairChildren(f.admin, repairShip);
+    REQUIRE(children.size() == 2);
+    for (const entt::entity child : children)
+    {
+        REQUIRE(f.admin.get<RepairToolComponent>(child).currentTarget == targetB);
+    }
+}
+
+TEST_CASE("BehaviorSystem: tickRepairTools does not crash when owner lacks RepairBehaviorComponent",
+          "[behavior]")
+{
+    Fixture f;
+
+    // Bare child entity: has RepairToolComponent and ModuleOwnerComponent but owner has no
+    // RepairBehaviorComponent.
+    const entt::entity ownerShip = f.ships.spawn("interceptor", 1, QVector2D(0.0f, 0.0f));
+    const entt::entity moduleEntity = f.admin.createModuleEntity();
+    RepairToolComponent rt;
+    rt.ratePerTick    = 1.0f;
+    rt.range          = 10.0f;
+    rt.currentTarget  = std::nullopt;
+    f.admin.addComponent<RepairToolComponent>(moduleEntity, rt);
+    f.admin.addComponent<ModuleOwnerComponent>(moduleEntity, ModuleOwnerComponent{ownerShip});
+
+    // Must not crash.
+    f.ai.tickRepairTools(f.admin);
+
+    REQUIRE_FALSE(f.admin.get<RepairToolComponent>(moduleEntity).currentTarget.has_value());
+}
+
 // ---------------------------------------------------------------------------
 // tickSalvageBehavior
 // ---------------------------------------------------------------------------
@@ -353,7 +628,9 @@ TEST_CASE("BehaviorSystem: repair ship does not heal above maxHp", "[behavior]")
 TEST_CASE("BehaviorSystem: salvage ship writes intent toward nearest scrap", "[behavior]")
 {
    Fixture f;
-    const entt::entity ship = f.ships.spawn("salvage_ship", 1, QVector2D(0.0f, 0.0f));
+    const ShipLayoutConfig salvageLayout = makeSingleModuleLayout("salvage_bay_module");
+    const entt::entity ship = f.ships.spawn("salvage_ship", 1, QVector2D(0.0f, 0.0f),
+                                             false, salvageLayout);

    const QVector2D scrapPos(100.0f, 0.0f);
    f.scraps.spawn(scrapPos, 1, 100000);
@@ -368,13 +645,17 @@ TEST_CASE("BehaviorSystem: salvage ship writes intent toward nearest scrap", "[b
 TEST_CASE("BehaviorSystem: salvage ship collects scrap on arrival", "[behavior]")
 {
    Fixture f;
-    const entt::entity ship       = f.ships.spawn("salvage_ship", 1, QVector2D(0.0f, 0.0f));
+    const ShipLayoutConfig salvageLayout = makeSingleModuleLayout("salvage_bay_module");
+    const entt::entity ship       = f.ships.spawn("salvage_ship", 1, QVector2D(0.0f, 0.0f),
+                                                   false, salvageLayout);
    const entt::entity scrapEntity = f.scraps.spawn(QVector2D(0.0f, 0.0f), 1, 100000);

    f.ships.clearMovementIntents();
    f.ai.tickSalvageBehavior(f.admin, f.scraps, f.buildings);

-    REQUIRE(f.admin.get<SalvageCargoComponent>(ship).current == 1);
+    const entt::entity sc = firstSalvageChild(f.admin, ship);
+    REQUIRE(f.admin.isValid(sc));
+    REQUIRE(f.admin.get<SalvageCargoComponent>(sc).current == 1);
    REQUIRE_FALSE(f.admin.isValid(scrapEntity));
 }

@@ -395,9 +676,15 @@ TEST_CASE("BehaviorSystem: full-cargo salvage ship moves toward SalvageBay", "[b
    }
    REQUIRE(f.buildings.findBuilding(bayId) != nullptr);

-    const entt::entity ship = f.ships.spawn("salvage_ship", 1, QVector2D(5.0f, 0.0f));
-    SalvageCargoComponent& cargo = f.admin.get<SalvageCargoComponent>(ship);
-    cargo.current = cargo.capacity;  // full cargo
+    const ShipLayoutConfig salvageLayout = makeSingleModuleLayout("salvage_bay_module");
+    const entt::entity ship = f.ships.spawn("salvage_ship", 1, QVector2D(5.0f, 0.0f),
+                                             false, salvageLayout);
+    {
+        const entt::entity sc = firstSalvageChild(f.admin, ship);
+        REQUIRE(f.admin.isValid(sc));
+        SalvageCargoComponent& cargo = f.admin.get<SalvageCargoComponent>(sc);
+        cargo.current = cargo.capacity;  // full cargo
+    }

    f.ships.clearMovementIntents();
    f.ai.tickSalvageBehavior(f.admin, f.scraps, f.buildings);
@@ -407,6 +694,165 @@ TEST_CASE("BehaviorSystem: full-cargo salvage ship moves toward SalvageBay", "[b
    REQUIRE(i.target.x() < pos(f.admin, ship).value.x());
 }

+// ---------------------------------------------------------------------------
+// Collection range (per-module)
+// ---------------------------------------------------------------------------
+
+static int totalSalvageCurrent(EntityAdmin& admin, entt::entity ship)
+{
+    int total = 0;
+    admin.forEach<SalvageCargoComponent, ModuleOwnerComponent>(
+        [&](entt::entity /*ce*/, const SalvageCargoComponent& c, const ModuleOwnerComponent& o)
+        {
+            if (o.owner == ship) { total += c.current; }
+        });
+    return total;
+}
+
+TEST_CASE("BehaviorSystem: salvage module does not collect scrap beyond its collection range",
+          "[behavior]")
+{
+    // collection_range_formula = "50"; scrap at distance 55 must not be collected.
+    Fixture f;
+    const ShipLayoutConfig salvageLayout = makeSingleModuleLayout("salvage_bay_module");
+    const entt::entity ship = f.ships.spawn("salvage_ship", 1, QVector2D(0.0f, 0.0f),
+                                             false, salvageLayout);
+    f.scraps.spawn(QVector2D(55.0f, 0.0f), 1, 100000);
+
+    f.ships.clearMovementIntents();
+    f.ai.tickSalvageBehavior(f.admin, f.scraps, f.buildings);
+
+    REQUIRE(f.admin.get<SalvageCargoComponent>(firstSalvageChild(f.admin, ship)).current == 0);
+}
+
+TEST_CASE("BehaviorSystem: salvage module collects scrap within its collection range",
+          "[behavior]")
+{
+    // collection_range_formula = "50"; scrap at distance 45 must be collected.
+    Fixture f;
+    const ShipLayoutConfig salvageLayout = makeSingleModuleLayout("salvage_bay_module");
+    const entt::entity ship = f.ships.spawn("salvage_ship", 1, QVector2D(0.0f, 0.0f),
+                                             false, salvageLayout);
+    f.scraps.spawn(QVector2D(45.0f, 0.0f), 1, 100000);
+
+    f.ships.clearMovementIntents();
+    f.ai.tickSalvageBehavior(f.admin, f.scraps, f.buildings);
+
+    REQUIRE(f.admin.get<SalvageCargoComponent>(firstSalvageChild(f.admin, ship)).current == 1);
+}
+
+// ---------------------------------------------------------------------------
+// Collection rate (per-module cooldown)
+// ---------------------------------------------------------------------------
+
+TEST_CASE("BehaviorSystem: salvage collection sets cooldown on module", "[behavior]")
+{
+    Fixture f;
+    const ShipLayoutConfig salvageLayout = makeSingleModuleLayout("salvage_bay_module");
+    const entt::entity ship = f.ships.spawn("salvage_ship", 1, QVector2D(0.0f, 0.0f),
+                                             false, salvageLayout);
+    f.scraps.spawn(QVector2D(0.0f, 0.0f), 1, 100000);
+
+    f.ships.clearMovementIntents();
+    f.ai.tickSalvageBehavior(f.admin, f.scraps, f.buildings);
+
+    const SalvageCargoComponent& cargo =
+        f.admin.get<SalvageCargoComponent>(firstSalvageChild(f.admin, ship));
+    REQUIRE(cargo.current == 1);
+    REQUIRE(cargo.cooldownTicksRemaining == cargo.collectionIntervalTicks);
+}
+
+TEST_CASE("BehaviorSystem: salvage module on cooldown does not collect scrap", "[behavior]")
+{
+    Fixture f;
+    const ShipLayoutConfig salvageLayout = makeSingleModuleLayout("salvage_bay_module");
+    const entt::entity ship = f.ships.spawn("salvage_ship", 1, QVector2D(0.0f, 0.0f),
+                                             false, salvageLayout);
+    f.scraps.spawn(QVector2D(0.0f, 0.0f), 1, 100000);
+
+    f.admin.get<SalvageCargoComponent>(firstSalvageChild(f.admin, ship)).cooldownTicksRemaining = 10;
+
+    f.ships.clearMovementIntents();
+    f.ai.tickSalvageBehavior(f.admin, f.scraps, f.buildings);
+
+    REQUIRE(f.admin.get<SalvageCargoComponent>(firstSalvageChild(f.admin, ship)).current == 0);
+}
+
+TEST_CASE("BehaviorSystem: salvage module collects again after cooldown expires", "[behavior]")
+{
+    Fixture f;
+    const ShipLayoutConfig salvageLayout = makeSingleModuleLayout("salvage_bay_module");
+    const entt::entity ship = f.ships.spawn("salvage_ship", 1, QVector2D(0.0f, 0.0f),
+                                             false, salvageLayout);
+    const entt::entity sc = firstSalvageChild(f.admin, ship);
+
+    f.scraps.spawn(QVector2D(0.0f, 0.0f), 1, 100000);
+    f.ships.clearMovementIntents();
+    f.ai.tickSalvageBehavior(f.admin, f.scraps, f.buildings);
+    REQUIRE(f.admin.get<SalvageCargoComponent>(sc).current == 1);
+
+    // Shorten cooldown to 1 tick and place a second scrap.
+    f.admin.get<SalvageCargoComponent>(sc).cooldownTicksRemaining = 1;
+    f.scraps.spawn(QVector2D(0.0f, 0.0f), 1, 100000);
+
+    // Next tick: cooldown decrements to 0, module collects the second scrap.
+    f.ships.clearMovementIntents();
+    f.ai.tickSalvageBehavior(f.admin, f.scraps, f.buildings);
+
+    REQUIRE(f.admin.get<SalvageCargoComponent>(sc).current == 2);
+}
+
+// ---------------------------------------------------------------------------
+// Multiple salvage modules
+// ---------------------------------------------------------------------------
+
+TEST_CASE("BehaviorSystem: two salvage modules collect independently in same tick", "[behavior]")
+{
+    Fixture f;
+    const ShipLayoutConfig salvageLayout = makeTwoModuleLayout("salvage_bay_module");
+    const entt::entity ship = f.ships.spawn("salvage_ship", 1, QVector2D(0.0f, 0.0f),
+                                             false, salvageLayout);
+
+    f.scraps.spawn(QVector2D(0.0f, 0.0f), 1, 100000);
+    f.scraps.spawn(QVector2D(0.0f, 0.0f), 1, 100000);
+
+    f.ships.clearMovementIntents();
+    f.ai.tickSalvageBehavior(f.admin, f.scraps, f.buildings);
+
+    REQUIRE(totalSalvageCurrent(f.admin, ship) == 2);
+}
+
+TEST_CASE("BehaviorSystem: second salvage module does not collect when first module is on cooldown",
+          "[behavior]")
+{
+    // One module on cooldown, one ready: only the ready module collects.
+    Fixture f;
+    const ShipLayoutConfig salvageLayout = makeTwoModuleLayout("salvage_bay_module");
+    const entt::entity ship = f.ships.spawn("salvage_ship", 1, QVector2D(0.0f, 0.0f),
+                                             false, salvageLayout);
+
+    // Put the first salvage child on cooldown.
+    entt::entity blocked = entt::null;
+    f.admin.forEach<SalvageCargoComponent, ModuleOwnerComponent>(
+        [&](entt::entity ce, SalvageCargoComponent& c, const ModuleOwnerComponent& o)
+        {
+            if (o.owner == ship && blocked == entt::null)
+            {
+                c.cooldownTicksRemaining = 99;
+                blocked = ce;
+            }
+        });
+
+    f.scraps.spawn(QVector2D(0.0f, 0.0f), 1, 100000);
+    f.scraps.spawn(QVector2D(0.0f, 0.0f), 1, 100000);
+
+    f.ships.clearMovementIntents();
+    f.ai.tickSalvageBehavior(f.admin, f.scraps, f.buildings);
+
+    // Only one module was ready, so only one scrap is collected.
+    REQUIRE(totalSalvageCurrent(f.admin, ship) == 1);
+}
+
 // ---------------------------------------------------------------------------
 // Sensor range — spawn
 // ---------------------------------------------------------------------------
@@ -467,7 +913,9 @@ TEST_CASE("SensorRange: enemy ship ignores player just outside sensor range", "[
 TEST_CASE("SensorRange: repair ship retreats from enemy within sensor range", "[sensor]")
 {
    Fixture f;
-    const entt::entity repairShip = f.ships.spawn("repair_ship", 1, QVector2D(0.0f, 0.0f));
+    const ShipLayoutConfig repairLayout = makeSingleModuleLayout("repair_tool_module");
+    const entt::entity repairShip = f.ships.spawn("repair_ship", 1, QVector2D(0.0f, 0.0f),
+                                                   false, repairLayout);
    f.ships.spawn("interceptor", 1, QVector2D(200.0f, 0.0f), /*isEnemy=*/true);

    f.ships.clearMovementIntents();
@@ -480,7 +928,9 @@ TEST_CASE("SensorRange: repair ship retreats from enemy within sensor range", "[
 TEST_CASE("SensorRange: repair ship does not retreat from enemy beyond sensor range", "[sensor]")
 {
    Fixture f;
-    const entt::entity repairShip = f.ships.spawn("repair_ship", 1, QVector2D(0.0f, 0.0f));
+    const ShipLayoutConfig repairLayout = makeSingleModuleLayout("repair_tool_module");
+    const entt::entity repairShip = f.ships.spawn("repair_ship", 1, QVector2D(0.0f, 0.0f),
+                                                   false, repairLayout);
    f.ships.spawn("interceptor", 1, QVector2D(300.0f, 0.0f), /*isEnemy=*/true);

    f.ships.clearMovementIntents();
@@ -492,7 +942,9 @@ TEST_CASE("SensorRange: repair ship does not retreat from enemy beyond sensor ra
 TEST_CASE("SensorRange: repair ship does not acquire damaged ally beyond sensor range", "[sensor]")
 {
    Fixture f;
-    const entt::entity repairShip = f.ships.spawn("repair_ship",  1, QVector2D(0.0f, 0.0f));
+    const ShipLayoutConfig repairLayout = makeSingleModuleLayout("repair_tool_module");
+    const entt::entity repairShip = f.ships.spawn("repair_ship",  1, QVector2D(0.0f, 0.0f),
+                                                   false, repairLayout);
    const entt::entity friendly   = f.ships.spawn("interceptor",  1, QVector2D(300.0f, 0.0f));
    f.admin.get<HealthComponent>(friendly).hp = f.admin.get<HealthComponent>(friendly).maxHp * 0.5f;

@@ -509,7 +961,9 @@ TEST_CASE("SensorRange: repair ship does not acquire damaged ally beyond sensor
 TEST_CASE("SensorRange: salvage ship ignores scrap beyond sensor range", "[sensor]")
 {
    Fixture f;
-    const entt::entity ship = f.ships.spawn("salvage_ship", 1, QVector2D(0.0f, 0.0f));
+    const ShipLayoutConfig salvageLayout = makeSingleModuleLayout("salvage_bay_module");
+    const entt::entity ship = f.ships.spawn("salvage_ship", 1, QVector2D(0.0f, 0.0f),
+                                             false, salvageLayout);
    f.scraps.spawn(QVector2D(300.0f, 0.0f), 1, 100000);

    f.ships.clearMovementIntents();
--- a/src/test/CombatSystemTest.cpp
+++ b/src/test/CombatSystemTest.cpp
@@ -13,6 +13,7 @@
 #include "FireEvent.h"
 #include "HealthComponent.h"
 #include "HqProxyComponent.h"
+#include "ModuleOwnerComponent.h"
 #include "ScrapSystem.h"
 #include "ShipSystem.h"
 #include "Simulation.h"
@@ -30,7 +31,7 @@ static const ShipDef* findCombatShip(const GameConfig& cfg)
 {
    for (const ShipDef& def : cfg.ships.ships)
    {
-        if (def.combat)
+        if (!def.defaultModules.empty())
        {
            return &def;
        }
@@ -38,6 +39,17 @@ static const ShipDef* findCombatShip(const GameConfig& cfg)
    return nullptr;
 }

+static entt::entity findWeaponChild(EntityAdmin& admin, entt::entity ship)
+{
+    entt::entity result = entt::null;
+    admin.forEach<WeaponComponent, ModuleOwnerComponent>(
+        [&](entt::entity ce, const WeaponComponent&, const ModuleOwnerComponent& o)
+        {
+            if (o.owner == ship && result == entt::null) { result = ce; }
+        });
+    return result;
+}
+
 // Helper fixture for unit tests that need ships + combat but not a full Simulation.
 struct CombatFixture
 {
@@ -67,10 +79,13 @@ struct CombatFixture

    void wireEnemyTarget(entt::entity enemy, entt::entity playerTarget)
    {
-        if (admin.hasAll<WeaponComponent>(enemy))
+        // Set target on weapon child entity (CombatSystem syncs from ThreatResponse each tick,
+        // but also setting directly ensures the first tick fires without waiting for sync).
+        const entt::entity wc = findWeaponChild(admin, enemy);
+        if (wc != entt::null)
        {
-            admin.get<WeaponComponent>(enemy).currentTarget = playerTarget;
-            admin.get<WeaponComponent>(enemy).cooldownTicks = 0.0f;
+            admin.get<WeaponComponent>(wc).currentTarget = playerTarget;
+            admin.get<WeaponComponent>(wc).cooldownTicks = 0.0f;
        }
        if (admin.hasAll<ThreatResponseBehaviorComponent>(enemy))
        {
@@ -113,7 +128,11 @@ TEST_CASE("CombatSystem: cooldown prevents firing before it expires", "[combat]"
    const entt::entity player = f.ships.spawn(combatDef->id, 1, QVector2D(4.0f, 5.0f), false);

    f.wireEnemyTarget(enemy, player);
-    f.admin.get<WeaponComponent>(enemy).cooldownTicks = 3.0f;  // override to 3
+    {
+        const entt::entity wc = findWeaponChild(f.admin, enemy);
+        REQUIRE(f.admin.isValid(wc));
+        f.admin.get<WeaponComponent>(wc).cooldownTicks = 3.0f;  // override to 3
+    }

    auto enemyFiredIn = [&enemy](const std::vector<FireEvent>& evts)
    {
--- a/src/test/ConfigLoaderTest.cpp
+++ b/src/test/ConfigLoaderTest.cpp
@@ -108,23 +108,19 @@ TEST_CASE("ConfigLoader loads the committed bin/config/ configs end-to-end", "[c
    REQUIRE(ironIngotIt->outputs.size() == 1);
    REQUIRE_FALSE(ironIngotIt->outputs[0].probability.has_value());

-    // ships.toml — combat ships have a combat section; salvage ships don't.
+    // ships.toml — combat ships have default_modules with a weapon; salvage ships don't.
    const auto interceptorIt = std::find_if(
        cfg.ships.ships.begin(), cfg.ships.ships.end(),
        [](const ShipDef& s) { return s.id == "interceptor"; });
    REQUIRE(interceptorIt != cfg.ships.ships.end());
-    REQUIRE(interceptorIt->combat.has_value());
-    REQUIRE_FALSE(interceptorIt->salvage.has_value());
-    REQUIRE_FALSE(interceptorIt->repair.has_value());
-    REQUIRE(interceptorIt->combat->damageFormula.evaluate(5.0) == Approx(20.0)); // "10 + 2*x"
+    REQUIRE_FALSE(interceptorIt->defaultModules.empty());
+    REQUIRE(interceptorIt->defaultModules[0].moduleId == "laser_cannon");

    const auto salvageShipIt = std::find_if(
        cfg.ships.ships.begin(), cfg.ships.ships.end(),
        [](const ShipDef& s) { return s.id == "salvage_ship"; });
    REQUIRE(salvageShipIt != cfg.ships.ships.end());
-    REQUIRE_FALSE(salvageShipIt->combat.has_value());
-    REQUIRE(salvageShipIt->salvage.has_value());
-    REQUIRE(salvageShipIt->salvage->cargoCapacity == 10);
+    REQUIRE(salvageShipIt->defaultModules.empty());

    // stations.toml
    REQUIRE(cfg.stations.playerStation.level == 5);
--- a/src/test/ShipTest.cpp
+++ b/src/test/ShipTest.cpp
@@ -3,6 +3,7 @@
 #include <cmath>
 #include <string>

+#include <QPoint>
 #include <QVector2D>

 #include "BuildingId.h"
@@ -10,11 +11,14 @@
 #include "DynamicBodyComponent.h"
 #include "EntityAdmin.h"
 #include "HealthComponent.h"
+#include "ModuleOwnerComponent.h"
 #include "RepairBehaviorComponent.h"
 #include "RepairToolComponent.h"
+#include "Rotation.h"
 #include "SalvageBehaviorComponent.h"
 #include "SalvageCargoComponent.h"
 #include "SensorRangeComponent.h"
+#include "ShipLayout.h"
 #include "ShipSystem.h"
 #include "Tick.h"
 #include "ThreatResponseBehaviorComponent.h"
@@ -26,10 +30,58 @@ static GameConfig loadConfig()
 }

 // ---------------------------------------------------------------------------
-// Combat ship
+// Helpers
 // ---------------------------------------------------------------------------

-TEST_CASE("ShipSystem: interceptor spawn has weapon and threatResponse, no cargo or repair",
+static entt::entity firstWeaponChild(EntityAdmin& admin, entt::entity ship)
+{
+    entt::entity result = entt::null;
+    admin.forEach<WeaponComponent, ModuleOwnerComponent>(
+        [&](entt::entity ce, const WeaponComponent&, const ModuleOwnerComponent& o)
+        {
+            if (o.owner == ship && result == entt::null) { result = ce; }
+        });
+    return result;
+}
+
+static entt::entity firstSalvageChild(EntityAdmin& admin, entt::entity ship)
+{
+    entt::entity result = entt::null;
+    admin.forEach<SalvageCargoComponent, ModuleOwnerComponent>(
+        [&](entt::entity ce, const SalvageCargoComponent&, const ModuleOwnerComponent& o)
+        {
+            if (o.owner == ship && result == entt::null) { result = ce; }
+        });
+    return result;
+}
+
+static entt::entity firstRepairChild(EntityAdmin& admin, entt::entity ship)
+{
+    entt::entity result = entt::null;
+    admin.forEach<RepairToolComponent, ModuleOwnerComponent>(
+        [&](entt::entity ce, const RepairToolComponent&, const ModuleOwnerComponent& o)
+        {
+            if (o.owner == ship && result == entt::null) { result = ce; }
+        });
+    return result;
+}
+
+static ShipLayoutConfig makeSingleModuleLayout(const std::string& moduleId)
+{
+    PlacedModule pm;
+    pm.moduleId = moduleId;
+    pm.position = QPoint(0, 0);
+    pm.rotation = Rotation::East;
+    ShipLayoutConfig layout;
+    layout.placedModules.push_back(pm);
+    return layout;
+}
+
+// ---------------------------------------------------------------------------
+// Combat ship (interceptor has default_modules = [laser_cannon])
+// ---------------------------------------------------------------------------
+
+TEST_CASE("ShipSystem: interceptor spawn has weapon child and threatResponse, no cargo or repair",
          "[ship]")
 {
    EntityAdmin admin;
@@ -39,10 +91,10 @@ TEST_CASE("ShipSystem: interceptor spawn has weapon and threatResponse, no cargo
    const entt::entity e = ss.spawn("interceptor", 1, QVector2D(0.0f, 0.0f));

    REQUIRE(admin.isValid(e));
-    REQUIRE(admin.hasAll<WeaponComponent>(e));
+    REQUIRE(admin.isValid(firstWeaponChild(admin, e)));
    REQUIRE(admin.hasAll<ThreatResponseBehaviorComponent>(e));
-    REQUIRE_FALSE(admin.hasAll<SalvageCargoComponent>(e));
-    REQUIRE_FALSE(admin.hasAll<RepairToolComponent>(e));
+    REQUIRE_FALSE(admin.isValid(firstSalvageChild(admin, e)));
+    REQUIRE_FALSE(admin.isValid(firstRepairChild(admin, e)));
    REQUIRE_FALSE(admin.hasAll<RepairBehaviorComponent>(e));
    REQUIRE_FALSE(admin.hasAll<SalvageBehaviorComponent>(e));
 }
@@ -58,14 +110,15 @@ TEST_CASE("ShipSystem: interceptor level 1 stats match config formulas", "[ship]
    // hp_formula = "40 + 5*x" at x=1 → 45
    REQUIRE(admin.get<HealthComponent>(e).maxHp == Approx(45.0f));
    REQUIRE(admin.get<HealthComponent>(e).hp    == Approx(45.0f));
-    // damage_formula = "10 + 2*x" at x=1 → 12
-    REQUIRE(admin.get<WeaponComponent>(e).damage == Approx(12.0f));
-    // attack_range_formula = "150"
-    REQUIRE(admin.get<WeaponComponent>(e).range == Approx(150.0f));
    // sensor_range_formula = "200"
    REQUIRE(admin.get<SensorRangeComponent>(e).value == Approx(200.0f));
-    // cooldownTicks starts at 0
-    REQUIRE(admin.get<WeaponComponent>(e).cooldownTicks == Approx(0.0f));
+
+    // laser_cannon: damage_formula = "2", attack_range_formula = "5"
+    const entt::entity wc = firstWeaponChild(admin, e);
+    REQUIRE(admin.isValid(wc));
+    REQUIRE(admin.get<WeaponComponent>(wc).damage == Approx(2.0f));
+    REQUIRE(admin.get<WeaponComponent>(wc).range  == Approx(5.0f));
+    REQUIRE(admin.get<WeaponComponent>(wc).cooldownTicks == Approx(0.0f));
 }

 TEST_CASE("ShipSystem: interceptor level 5 hp matches formula", "[ship]")
@@ -94,22 +147,23 @@ TEST_CASE("ShipSystem: interceptor level 0 maxSpeedPerTick matches formula / kTi
 }

 // ---------------------------------------------------------------------------
-// Salvage ship
+// Salvage ship (spawned with salvage_bay_module layout)
 // ---------------------------------------------------------------------------

-TEST_CASE("ShipSystem: salvage_ship spawn has cargo and scrapCollector, no weapon",
+TEST_CASE("ShipSystem: salvage_ship spawn with salvage module has cargo child and behavior, no weapon",
          "[ship]")
 {
    EntityAdmin admin;
    const GameConfig cfg = loadConfig();
    ShipSystem ss(cfg, admin);

-    const entt::entity e = ss.spawn("salvage_ship", 1, QVector2D(0.0f, 0.0f));
+    const ShipLayoutConfig layout = makeSingleModuleLayout("salvage_bay_module");
+    const entt::entity e = ss.spawn("salvage_ship", 1, QVector2D(0.0f, 0.0f), false, layout);

-    REQUIRE(admin.hasAll<SalvageCargoComponent>(e));
+    REQUIRE(admin.isValid(firstSalvageChild(admin, e)));
    REQUIRE(admin.hasAll<SalvageBehaviorComponent>(e));
-    REQUIRE_FALSE(admin.hasAll<WeaponComponent>(e));
-    REQUIRE_FALSE(admin.hasAll<RepairToolComponent>(e));
+    REQUIRE_FALSE(admin.isValid(firstWeaponChild(admin, e)));
+    REQUIRE_FALSE(admin.isValid(firstRepairChild(admin, e)));
 }

 TEST_CASE("ShipSystem: salvage_ship cargo capacity matches config", "[ship]")
@@ -118,32 +172,37 @@ TEST_CASE("ShipSystem: salvage_ship cargo capacity matches config", "[ship]")
    const GameConfig cfg = loadConfig();
    ShipSystem ss(cfg, admin);

-    const entt::entity e = ss.spawn("salvage_ship", 1, QVector2D(0.0f, 0.0f));
+    const ShipLayoutConfig layout = makeSingleModuleLayout("salvage_bay_module");
+    const entt::entity e = ss.spawn("salvage_ship", 1, QVector2D(0.0f, 0.0f), false, layout);

-    // cargo_capacity = 10
-    REQUIRE(admin.get<SalvageCargoComponent>(e).capacity == 10);
-    REQUIRE(admin.get<SalvageCargoComponent>(e).current  == 0);
+    // salvage_bay_module: cargo_capacity_formula = "10", collection_range_formula = "50"
+    const entt::entity sc = firstSalvageChild(admin, e);
+    REQUIRE(admin.isValid(sc));
+    REQUIRE(admin.get<SalvageCargoComponent>(sc).capacity == 10);
+    REQUIRE(admin.get<SalvageCargoComponent>(sc).current  == 0);
    REQUIRE(admin.get<SalvageBehaviorComponent>(e).deliveryBay == kInvalidBuildingId);
    REQUIRE_FALSE(admin.get<SalvageBehaviorComponent>(e).scrapTarget.has_value());
+    REQUIRE(admin.get<SalvageBehaviorComponent>(e).maxCollectionRange == Approx(50.0f));
 }

 // ---------------------------------------------------------------------------
-// Repair ship
+// Repair ship (spawned with repair_tool_module layout)
 // ---------------------------------------------------------------------------

-TEST_CASE("ShipSystem: repair_ship spawn has repairTool and repairBehavior, no weapon",
+TEST_CASE("ShipSystem: repair_ship spawn with repair module has repair child and behavior, no weapon",
          "[ship]")
 {
    EntityAdmin admin;
    const GameConfig cfg = loadConfig();
    ShipSystem ss(cfg, admin);

-    const entt::entity e = ss.spawn("repair_ship", 1, QVector2D(0.0f, 0.0f));
+    const ShipLayoutConfig layout = makeSingleModuleLayout("repair_tool_module");
+    const entt::entity e = ss.spawn("repair_ship", 1, QVector2D(0.0f, 0.0f), false, layout);

-    REQUIRE(admin.hasAll<RepairToolComponent>(e));
+    REQUIRE(admin.isValid(firstRepairChild(admin, e)));
    REQUIRE(admin.hasAll<RepairBehaviorComponent>(e));
-    REQUIRE_FALSE(admin.hasAll<WeaponComponent>(e));
-    REQUIRE_FALSE(admin.hasAll<SalvageCargoComponent>(e));
+    REQUIRE_FALSE(admin.isValid(firstWeaponChild(admin, e)));
+    REQUIRE_FALSE(admin.isValid(firstSalvageChild(admin, e)));
 }

 TEST_CASE("ShipSystem: repair_ship level 1 repair stats match config formulas", "[ship]")
@@ -152,12 +211,17 @@ TEST_CASE("ShipSystem: repair_ship level 1 repair stats match config formulas",
    const GameConfig cfg = loadConfig();
    ShipSystem ss(cfg, admin);

-    const entt::entity e = ss.spawn("repair_ship", 1, QVector2D(0.0f, 0.0f));
+    const ShipLayoutConfig layout = makeSingleModuleLayout("repair_tool_module");
+    const entt::entity e = ss.spawn("repair_ship", 1, QVector2D(0.0f, 0.0f), false, layout);

-    // repair_rate_formula = "5 + x" at x=1 → 6
-    REQUIRE(admin.get<RepairToolComponent>(e).ratePerTick == Approx(6.0f));
+    // repair_tool_module: repair_rate_formula = "5 + x" at x=1 → 6 / kTickRateHz
+    const float expectedRate = 6.0f / static_cast<float>(kTickRateHz);
+    const entt::entity rc = firstRepairChild(admin, e);
+    REQUIRE(admin.isValid(rc));
+    REQUIRE(admin.get<RepairToolComponent>(rc).ratePerTick == Approx(expectedRate));
    // repair_range_formula = "80"
-    REQUIRE(admin.get<RepairToolComponent>(e).range == Approx(80.0f));
+    REQUIRE(admin.get<RepairToolComponent>(rc).range == Approx(80.0f));
+    REQUIRE(admin.get<RepairBehaviorComponent>(e).maxRepairRange == Approx(80.0f));
 }

 // ---------------------------------------------------------------------------
@@ -171,22 +235,26 @@ TEST_CASE("ShipSystem: spawned ships are valid entities", "[ship]")
    ShipSystem ss(cfg, admin);

    const entt::entity e1 = ss.spawn("interceptor",  1, QVector2D(0.0f, 0.0f));
-    const entt::entity e2 = ss.spawn("salvage_ship", 1, QVector2D(1.0f, 0.0f));
+    const ShipLayoutConfig salvageLayout = makeSingleModuleLayout("salvage_bay_module");
+    const entt::entity e2 = ss.spawn("salvage_ship", 1, QVector2D(1.0f, 0.0f), false, salvageLayout);

    REQUIRE(admin.isValid(e1));
    REQUIRE(admin.isValid(e2));
    REQUIRE(e1 != e2);
 }

-TEST_CASE("ShipSystem: despawn removes the ship", "[ship]")
+TEST_CASE("ShipSystem: despawn removes the ship and its weapon children", "[ship]")
 {
    EntityAdmin admin;
    const GameConfig cfg = loadConfig();
    ShipSystem ss(cfg, admin);

-    const entt::entity e = ss.spawn("interceptor", 1, QVector2D(0.0f, 0.0f));
+    const entt::entity e  = ss.spawn("interceptor", 1, QVector2D(0.0f, 0.0f));
+    const entt::entity wc = firstWeaponChild(admin, e);
    REQUIRE(admin.isValid(e));
+    REQUIRE(admin.isValid(wc));

    ss.despawn(e);
    REQUIRE_FALSE(admin.isValid(e));
+    REQUIRE_FALSE(admin.isValid(wc));
 }
--- a/src/test/WaveSystemTest.cpp
+++ b/src/test/WaveSystemTest.cpp
@@ -10,6 +10,7 @@
 #include "FactionComponent.h"
 #include "HealthComponent.h"
 #include "HqProxyComponent.h"
+#include "ModuleOwnerComponent.h"
 #include "Rotation.h"
 #include "ShipIdentityComponent.h"
 #include "ShipSystem.h"
@@ -166,13 +167,14 @@ TEST_CASE("WaveSystem: HQ anchor is at asteroid right edge", "[wave]")

 TEST_CASE("WaveSystem: player stations have weapon set", "[wave]")
 {
-    const Simulation sim(loadConfig(), 42);
+    Simulation sim(loadConfig(), 42);

    int armedPlayerStations = 0;
-    sim.admin().forEach<StationBodyComponent, FactionComponent, WeaponComponent>(
-        [&](entt::entity /*e*/, const StationBodyComponent& /*sb*/, const FactionComponent& f,
-            const WeaponComponent& w)
+    sim.admin().forEach<WeaponComponent, ModuleOwnerComponent>(
+        [&](entt::entity /*e*/, const WeaponComponent& w, const ModuleOwnerComponent& mo)
        {
+            if (!sim.admin().hasAll<StationBodyComponent>(mo.owner)) { return; }
+            const FactionComponent& f = sim.admin().get<FactionComponent>(mo.owner);
            if (!f.isEnemy)
            {
                ++armedPlayerStations;
@@ -186,13 +188,14 @@ TEST_CASE("WaveSystem: player stations have weapon set", "[wave]")

 TEST_CASE("WaveSystem: enemy stations have weapon set", "[wave]")
 {
-    const Simulation sim(loadConfig(), 42);
+    Simulation sim(loadConfig(), 42);

    int armedEnemyStations = 0;
-    sim.admin().forEach<StationBodyComponent, FactionComponent, WeaponComponent>(
-        [&](entt::entity /*e*/, const StationBodyComponent& /*sb*/, const FactionComponent& f,
-            const WeaponComponent& w)
+    sim.admin().forEach<WeaponComponent, ModuleOwnerComponent>(
+        [&](entt::entity /*e*/, const WeaponComponent& w, const ModuleOwnerComponent& mo)
        {
+            if (!sim.admin().hasAll<StationBodyComponent>(mo.owner)) { return; }
+            const FactionComponent& f = sim.admin().get<FactionComponent>(mo.owner);
            if (f.isEnemy)
            {
                ++armedEnemyStations;
--- a/src/ui/GameWorldView.cpp
+++ b/src/ui/GameWorldView.cpp
@@ -24,8 +24,6 @@
 #include "FactionComponent.h"
 #include "HealthComponent.h"
 #include "PositionComponent.h"
-#include "RepairToolComponent.h"
-#include "SalvageCargoComponent.h"
 #include "ScrapSystem.h"
 #include "SensorRangeComponent.h"
 #include "ShipIdentityComponent.h"
@@ -62,13 +60,6 @@ Rotation rotateCounterClockwise(Rotation r)
    return Rotation::East;
 }

-ShipRole shipRoleFromComponents(bool isEnemy, bool hasCargo, bool hasRepairTool)
-{
-    if (isEnemy)      { return ShipRole::Enemy; }
-    if (hasCargo)     { return ShipRole::Salvage; }
-    if (hasRepairTool){ return ShipRole::Repair; }
-    return ShipRole::PlayerCombat;
-}

 QString toDisplayName(const std::string& id)
 {
@@ -847,15 +838,12 @@ void GameWorldView::drawShips(QPainter& painter)
 {
    m_sim->admin().forEach<ShipIdentityComponent, PositionComponent, FacingComponent,
                           FactionComponent>(
-        [&](entt::entity e, const ShipIdentityComponent& /*si*/,
+        [&](entt::entity /*e*/, const ShipIdentityComponent& si,
            const PositionComponent& pos, const FacingComponent& facing,
-            const FactionComponent& fac)
+            const FactionComponent& /*fac*/)
        {
-            const bool hasCargo  = m_sim->admin().hasAll<SalvageCargoComponent>(e);
-            const bool hasRepair = m_sim->admin().hasAll<RepairToolComponent>(e);
-            const ShipRole role  = shipRoleFromComponents(fac.isEnemy, hasCargo, hasRepair);
-            const std::map<ShipRole, ShipVisuals>::const_iterator it =
-                m_visuals->ships.find(role);
+            const std::map<std::string, ShipVisuals>::const_iterator it =
+                m_visuals->ships.find(si.schematicId);
            if (it == m_visuals->ships.end()) { return; }

            const QPointF center = worldToWidget(pos.value);
@@ -884,15 +872,12 @@ void GameWorldView::drawDebugSensorRanges(QPainter& painter)
    painter.setBrush(Qt::NoBrush);
    m_sim->admin().forEach<ShipIdentityComponent, PositionComponent, FacingComponent,
                           FactionComponent, SensorRangeComponent>(
-        [&](entt::entity e, const ShipIdentityComponent& /*si*/,
+        [&](entt::entity /*e*/, const ShipIdentityComponent& si,
            const PositionComponent& pos, const FacingComponent& /*facing*/,
-            const FactionComponent& fac, const SensorRangeComponent& sensor)
+            const FactionComponent& /*fac*/, const SensorRangeComponent& sensor)
        {
-            const bool hasCargo  = m_sim->admin().hasAll<SalvageCargoComponent>(e);
-            const bool hasRepair = m_sim->admin().hasAll<RepairToolComponent>(e);
-            const ShipRole role  = shipRoleFromComponents(fac.isEnemy, hasCargo, hasRepair);
-            const std::map<ShipRole, ShipVisuals>::const_iterator it =
-                m_visuals->ships.find(role);
+            const std::map<std::string, ShipVisuals>::const_iterator it =
+                m_visuals->ships.find(si.schematicId);
            if (it == m_visuals->ships.end()) { return; }

            const QPointF center   = worldToWidget(pos.value);
--- a/src/ui/VisualsConfig.h
+++ b/src/ui/VisualsConfig.h
@@ -55,14 +55,6 @@ struct ToastVisuals
    int    fontSize;
 };

-enum class ShipRole
-{
-    PlayerCombat,
-    Salvage,
-    Repair,
-    Enemy,
-};
-
 struct VisualsConfig
 {
    TileVisuals asteroid;
@@ -70,7 +62,7 @@ struct VisualsConfig

    std::map<BuildingType, BuildingVisuals> buildings;
    std::map<std::string,  ItemVisuals>     items;
-    std::map<ShipRole,     ShipVisuals>     ships;
+    std::map<std::string,  ShipVisuals>     ships;

    BeamVisuals    beams;
    OverlayVisuals overlays;
--- a/src/ui/VisualsLoader.cpp
+++ b/src/ui/VisualsLoader.cpp
@@ -190,17 +190,20 @@ VisualsConfig VisualsLoader::load(const std::string& path)
        }
    }

-    // Ships
+    // Ships (dynamic keys: each key is a schematic id)
    {
        toml::table& ships = requireSubtable(tbl, "ships", "root");
-        cfg.ships[ShipRole::PlayerCombat] = parseShip(
-            requireSubtable(ships, "player_combat", "ships"), "ships.player_combat");
-        cfg.ships[ShipRole::Salvage] = parseShip(
-            requireSubtable(ships, "salvage", "ships"), "ships.salvage");
-        cfg.ships[ShipRole::Repair] = parseShip(
-            requireSubtable(ships, "repair", "ships"), "ships.repair");
-        cfg.ships[ShipRole::Enemy] = parseShip(
-            requireSubtable(ships, "enemy", "ships"), "ships.enemy");
+        for (toml::table::iterator it = ships.begin(); it != ships.end(); ++it)
+        {
+            std::string schematicId = std::string(it->first.str());
+            toml::table* sub = it->second.as_table();
+            if (sub == nullptr)
+            {
+                throw std::runtime_error("visuals.toml: ships." + schematicId
+                                         + " is not a table");
+            }
+            cfg.ships[schematicId] = parseShip(*sub, "ships." + schematicId);
+        }
    }

    // Beams
Author	SHA1	Message	Date
mlangkabel	090dc64bc4	allow one target per repair tool module	2026-06-02 22:24:40 +02:00
mlangkabel	64f7c9dcc1	add tests for salvager range and cooldown	2026-06-02 21:39:05 +02:00
mlangkabel	f921f00a0d	add collection rate for salvager modules and respect collection range of each of these modules	2026-06-02 21:28:31 +02:00
mlangkabel	9d0a60a93b	define ship roles via added modules and allow multiple weapons	2026-06-01 23:05:21 +02:00
mlangkabel	f363f7a67c	documentation	2026-05-27 17:03:13 +02:00