allow multi-select for ships/stations, mixable with scrap

src/ui/GameWorldView.cpp

@@ -37,7 +37,7 @@
 #include "ReplayRecorder.h"
 #include "DemolishModeChangedEvent.h"
 #include "EntityHitTest.h"
-#include "EntitySelectedEvent.h"
+#include "EntitySelectionChangedEvent.h"
 #include "EventManager.h"
 #include "FacingComponent.h"
 #include "FactionComponent.h"
@@ -284,6 +284,7 @@ void GameWorldView::onFrame()
     // Drop selected scrap piles that were collected or despawned this frame, so the
     // panel stops counting them and the selection empties out (REQ-UI-SCRAP-CLICK-SELECT).
     pruneDespawnedScrap();
+    pruneDespawnedActors();
 
     // Expire copy/paste flashes. Lifetime is wall-clock (the frame delta), so the
     // flash plays for a fixed real duration regardless of game speed, including
@@ -725,6 +726,43 @@ void GameWorldView::pruneDespawnedScrap()
     }
 }
 
+void GameWorldView::clearEntitySelection()
+{
+    if (m_selectedEntities.empty()) { return; }
+    m_selectedEntities.clear();
+    EventManager::getInstance()->sendEventImmediately(
+        std::make_shared<EntitySelectionChangedEvent>(m_selectedEntities));
+}
+
+void GameWorldView::pruneDespawnedActors()
+{
+    if (m_selectedEntities.empty()) { return; }
+
+    EntityAdmin& admin = m_sim->getAdmin();
+    std::vector<entt::entity> live;
+    for (entt::entity e : m_selectedEntities)
+    {
+        if (admin.isValid(e) && admin.hasAll<HealthComponent>(e)
+            && admin.get<HealthComponent>(e).hp > 0.0f)
+        {
+            live.push_back(e);
+        }
+    }
+
+    if (live.size() != m_selectedEntities.size())
+    {
+        m_selectedEntities = std::move(live);
+        EventManager::getInstance()->sendEventImmediately(
+            std::make_shared<EntitySelectionChangedEvent>(m_selectedEntities));
+    }
+}
+
+bool GameWorldView::isEntitySelected(entt::entity entity) const
+{
+    return std::find(m_selectedEntities.begin(), m_selectedEntities.end(), entity)
+        != m_selectedEntities.end();
+}
+
 void GameWorldView::stepSpeed(int delta)
 {
     const double kSpeeds[] = { 0.0, 0.5, 1.0, 2.0, 10.0 };
@@ -1305,7 +1343,7 @@ void GameWorldView::drawStations(QPainter& painter)
             painter.setBrush(Qt::NoBrush);
             painter.drawRect(bboxRect);
 
-            if (m_selectedEntity.has_value() && *m_selectedEntity == e)
+            if (isEntitySelected(e))
             {
                 painter.setPen(QPen(m_visuals->overlays.selectedOutline, 2));
                 painter.setBrush(Qt::NoBrush);
@@ -1352,7 +1390,7 @@ void GameWorldView::drawShips(QPainter& painter)
             painter.setBrush(it->second.fill);
             painter.drawPolygon(tri);
 
-            if (m_selectedEntity.has_value() && *m_selectedEntity == e)
+            if (isEntitySelected(e))
             {
                 painter.setPen(QPen(m_visuals->overlays.selectedOutline, 2));
                 painter.setBrush(Qt::NoBrush);
@@ -2040,102 +2078,128 @@ void GameWorldView::mousePressEvent(QMouseEvent* event)
             }
         }
 
+        const bool ctrl = (event->modifiers() & Qt::ControlModifier) != 0;
         const QVector2D worldPos = widgetToWorld(event->pos());
-        const entt::entity hitEntity = entityAtWorldPos(m_sim->getAdmin(), worldPos);
 
-        if (hitEntity != entt::null)
+        // Point hit-test precedence: buildings win over actors, which win over scrap
+        // (REQ-UI-SELECTION-CATEGORIES).
+        std::optional<BuildingId> buildingHit = buildingAtTile(tile);
+        if (!buildingHit.has_value()) { buildingHit = siteAtTile(tile); }
+
+        if (buildingHit.has_value())
         {
-            // Actors (ship/station) win over scrap and buildings (REQ-UI-SCRAP-CLICK-SELECT).
+            const BuildingId id = *buildingHit;
+            // A building selection is exclusive: it clears any field selection —
+            // actors and scrap — because buildings win (REQ-UI-SELECTION-CATEGORIES).
+            clearEntitySelection();
             clearScrapSelection();
-            m_selectedBuildingIds.clear();
-            EventManager::getInstance()->sendEventImmediately(
-                std::make_shared<SelectionChangedEvent>(m_selectedBuildingIds));
-            m_selectedEntity = hitEntity;
-            EventManager::getInstance()->sendEventImmediately(
-                std::make_shared<EntitySelectedEvent>(hitEntity));
-        }
-        else
-        {
-            if (m_selectedEntity.has_value())
+            if (ctrl)
             {
-                m_selectedEntity = std::nullopt;
-                EventManager::getInstance()->sendEventImmediately(
-                    std::make_shared<EntitySelectedEvent>(std::nullopt));
-            }
-
-            std::optional<BuildingId> hit = buildingAtTile(tile);
-            if (!hit.has_value())
-            {
-                hit = siteAtTile(tile);
-            }
-            if (hit.has_value())
-            {
-                const BuildingId id = *hit;
-                // A building/construction site outranks scrap (REQ-UI-SCRAP-CLICK-SELECT).
-                clearScrapSelection();
-                if (event->modifiers() & Qt::ControlModifier)
+                bool found = false;
+                std::vector<BuildingId> newSel;
+                for (BuildingId sel : m_selectedBuildingIds)
                 {
-                    bool found = false;
-                    std::vector<BuildingId> newSel;
-                    for (BuildingId sel : m_selectedBuildingIds)
-                    {
-                        if (sel == id) { found = true; }
-                        else           { newSel.push_back(sel); }
-                    }
-                    if (!found) { newSel.push_back(id); }
-                    m_selectedBuildingIds = newSel;
+                    if (sel == id) { found = true; }
+                    else           { newSel.push_back(sel); }
                 }
-                else
-                {
-                    m_selectedBuildingIds = { id };
-                }
-                EventManager::getInstance()->sendEventImmediately(
-                std::make_shared<SelectionChangedEvent>(m_selectedBuildingIds));
-            }
-            else if (const entt::entity scrapHit =
-                         scrapAtWorldPos(m_sim->getAdmin(), worldPos); scrapHit != entt::null)
-            {
-                // Scrap forms its own selection category; picking it clears any
-                // building selection (REQ-UI-SCRAP-CLICK-SELECT, REQ-UI-SCRAP-MULTI-SELECT).
-                if (!m_selectedBuildingIds.empty())
-                {
-                    m_selectedBuildingIds.clear();
-                    EventManager::getInstance()->sendEventImmediately(
-                        std::make_shared<SelectionChangedEvent>(m_selectedBuildingIds));
-                }
-                if (event->modifiers() & Qt::ControlModifier)
-                {
-                    bool found = false;
-                    std::vector<entt::entity> newSel;
-                    for (entt::entity sel : m_selectedScrap)
-                    {
-                        if (sel == scrapHit) { found = true; }
-                        else                 { newSel.push_back(sel); }
-                    }
-                    if (!found) { newSel.push_back(scrapHit); }
-                    m_selectedScrap = newSel;
-                }
-                else
-                {
-                    m_selectedScrap = { scrapHit };
-                }
-                EventManager::getInstance()->sendEventImmediately(
-                    std::make_shared<ScrapSelectionChangedEvent>(m_selectedScrap));
+                if (!found) { newSel.push_back(id); }
+                m_selectedBuildingIds = newSel;
             }
             else
             {
-                if (!(event->modifiers() & Qt::ControlModifier))
-                {
-                    m_selectedBuildingIds.clear();
-                    EventManager::getInstance()->sendEventImmediately(
-                std::make_shared<SelectionChangedEvent>(m_selectedBuildingIds));
-                    clearScrapSelection();
-                }
-                m_boxSelecting    = true;
-                m_boxStartTile    = tile;
-                m_boxCurrentTile  = tile;
+                m_selectedBuildingIds = { id };
             }
+            EventManager::getInstance()->sendEventImmediately(
+                std::make_shared<SelectionChangedEvent>(m_selectedBuildingIds));
+            return;
         }
+
+        // Selecting a field object (actor or scrap) clears any building selection but
+        // lets actors and scrap coexist (REQ-UI-SELECTION-CATEGORIES).
+        const entt::entity actorHit = entityAtWorldPos(m_sim->getAdmin(), worldPos);
+        if (actorHit != entt::null)
+        {
+            if (!m_selectedBuildingIds.empty())
+            {
+                m_selectedBuildingIds.clear();
+                EventManager::getInstance()->sendEventImmediately(
+                    std::make_shared<SelectionChangedEvent>(m_selectedBuildingIds));
+            }
+            if (ctrl)
+            {
+                // Toggle this actor within the field selection, leaving scrap intact
+                // (REQ-UI-ENTITY-CLICK-SELECT).
+                bool found = false;
+                std::vector<entt::entity> newSel;
+                for (entt::entity sel : m_selectedEntities)
+                {
+                    if (sel == actorHit) { found = true; }
+                    else                 { newSel.push_back(sel); }
+                }
+                if (!found) { newSel.push_back(actorHit); }
+                m_selectedEntities = newSel;
+            }
+            else
+            {
+                // A plain click makes this actor the sole selection.
+                m_selectedEntities = { actorHit };
+                clearScrapSelection();
+            }
+            EventManager::getInstance()->sendEventImmediately(
+                std::make_shared<EntitySelectionChangedEvent>(m_selectedEntities));
+            return;
+        }
+
+        if (const entt::entity scrapHit =
+                scrapAtWorldPos(m_sim->getAdmin(), worldPos); scrapHit != entt::null)
+        {
+            if (!m_selectedBuildingIds.empty())
+            {
+                m_selectedBuildingIds.clear();
+                EventManager::getInstance()->sendEventImmediately(
+                    std::make_shared<SelectionChangedEvent>(m_selectedBuildingIds));
+            }
+            if (ctrl)
+            {
+                // Toggle this pile within the field selection, leaving actors intact
+                // (REQ-UI-SCRAP-MULTI-SELECT).
+                bool found = false;
+                std::vector<entt::entity> newSel;
+                for (entt::entity sel : m_selectedScrap)
+                {
+                    if (sel == scrapHit) { found = true; }
+                    else                 { newSel.push_back(sel); }
+                }
+                if (!found) { newSel.push_back(scrapHit); }
+                m_selectedScrap = newSel;
+            }
+            else
+            {
+                // A plain click makes this pile the sole selection.
+                m_selectedScrap = { scrapHit };
+                clearEntitySelection();
+            }
+            EventManager::getInstance()->sendEventImmediately(
+                std::make_shared<ScrapSelectionChangedEvent>(m_selectedScrap));
+            return;
+        }
+
+        // Empty space: a plain click clears the whole selection and starts a box drag;
+        // Ctrl preserves the current selection for additive box-select.
+        if (!ctrl)
+        {
+            if (!m_selectedBuildingIds.empty())
+            {
+                m_selectedBuildingIds.clear();
+                EventManager::getInstance()->sendEventImmediately(
+                    std::make_shared<SelectionChangedEvent>(m_selectedBuildingIds));
+            }
+            clearEntitySelection();
+            clearScrapSelection();
+        }
+        m_boxSelecting    = true;
+        m_boxStartTile    = tile;
+        m_boxCurrentTile  = tile;
     }
 }
 
@@ -2206,8 +2270,9 @@ void GameWorldView::mouseReleaseEvent(QMouseEvent* event)
 
         if (!boxIds.empty())
         {
-            // A box covering any building selects buildings; scrap in the box is
-            // ignored (REQ-UI-MULTI-SELECT, REQ-UI-SCRAP-MULTI-SELECT).
+            // A box covering any building selects buildings; field objects (actors and
+            // scrap) in the box are ignored — buildings win (REQ-UI-MULTI-SELECT).
+            clearEntitySelection();
             clearScrapSelection();
             if (!ctrl)
             {
@@ -2230,11 +2295,13 @@ void GameWorldView::mouseReleaseEvent(QMouseEvent* event)
             return;
         }
 
-        // No buildings in the box: a scrap-only box selects the scrap it covers
-        // (REQ-UI-SCRAP-MULTI-SELECT).
+        // No buildings in the box: select the field objects it covers — ships, defence
+        // stations, and scrap together (REQ-UI-MULTI-SELECT, REQ-UI-SCRAP-MULTI-SELECT).
+        const std::vector<entt::entity> boxActors =
+            actorsInBox(m_sim->getAdmin(), m_boxStartTile, m_boxCurrentTile);
         const std::vector<entt::entity> boxScrap =
             scrapInBox(m_sim->getAdmin(), m_boxStartTile, m_boxCurrentTile);
-        if (!boxScrap.empty())
+        if (!boxActors.empty() || !boxScrap.empty())
         {
             if (!m_selectedBuildingIds.empty())
             {
@@ -2244,10 +2311,20 @@ void GameWorldView::mouseReleaseEvent(QMouseEvent* event)
             }
             if (!ctrl)
             {
-                m_selectedScrap = boxScrap;
+                m_selectedEntities = boxActors;
+                m_selectedScrap    = boxScrap;
             }
             else
             {
+                for (entt::entity e : boxActors)
+                {
+                    bool found = false;
+                    for (entt::entity sel : m_selectedEntities)
+                    {
+                        if (sel == e) { found = true; break; }
+                    }
+                    if (!found) { m_selectedEntities.push_back(e); }
+                }
                 for (entt::entity e : boxScrap)
                 {
                     bool found = false;
@@ -2258,6 +2335,8 @@ void GameWorldView::mouseReleaseEvent(QMouseEvent* event)
                     if (!found) { m_selectedScrap.push_back(e); }
                 }
             }
+            EventManager::getInstance()->sendEventImmediately(
+                std::make_shared<EntitySelectionChangedEvent>(m_selectedEntities));
             EventManager::getInstance()->sendEventImmediately(
                 std::make_shared<ScrapSelectionChangedEvent>(m_selectedScrap));
             return;
@@ -2269,6 +2348,7 @@ void GameWorldView::mouseReleaseEvent(QMouseEvent* event)
             m_selectedBuildingIds.clear();
             EventManager::getInstance()->sendEventImmediately(
                 std::make_shared<SelectionChangedEvent>(m_selectedBuildingIds));
+            clearEntitySelection();
             clearScrapSelection();
         }
     }
@@ -2483,6 +2563,8 @@ void GameWorldView::resetForNewGame()
     EventManager::getInstance()->sendEventImmediately(
         std::make_shared<DemolishModeChangedEvent>(false));
     m_selectedBuildingIds.clear();
+    clearEntitySelection();
+    clearScrapSelection();
     m_copiedConfig     = std::nullopt;
     m_copyConfigFlashes.clear();
     m_boxSelecting     = false;

src/ui/GameWorldView.h

@@ -36,7 +36,7 @@
 
 #include "entt/entity/entity.hpp"
 #include "CommandManager.h"
-#include "EntitySelectedEvent.h"
+#include "EntitySelectionChangedEvent.h"
 #include "GameConfig.h"
 #include "Rotation.h"
 #include "Tick.h"
@@ -193,6 +193,14 @@ private:
     // Drops despawned or fully-collected piles from the scrap selection and re-emits
     // when it changed (REQ-UI-SCRAP-CLICK-SELECT). Called each frame from onFrame().
     void                     pruneDespawnedScrap();
+    // Clears the actor selection, emitting an empty EntitySelectionChangedEvent when it was
+    // non-empty (REQ-UI-ENTITY-CLICK-SELECT). Used when buildings take over.
+    void                     clearEntitySelection();
+    // Drops despawned or dead actors from the selection and re-emits when it changed
+    // (REQ-UI-ENTITY-CLICK-SELECT). Called each frame from onFrame().
+    void                     pruneDespawnedActors();
+    // True if the given actor is part of the current actor selection.
+    bool                     isEntitySelected(entt::entity entity) const;
     void                     stepSpeed(int delta);
     void                     placeAtTile(QPoint tile);
 
@@ -274,7 +282,7 @@ private:
     bool     m_debugDraw;
 
     std::vector<BuildingId> m_selectedBuildingIds;
-    std::optional<entt::entity> m_selectedEntity;
+    std::vector<entt::entity> m_selectedEntities;
     std::vector<entt::entity> m_selectedScrap;
     bool                  m_boxSelecting;
     QPoint                m_boxStartTile;

src/ui/SelectedBuildingPanel.cpp

@@ -9,14 +9,16 @@
 #include <QLabel>
 #include <QListWidget>
 #include <QPushButton>
+#include <QStringList>
 #include <QVBoxLayout>
 
 #include "BeltSystem.h"
 #include "Command.h"
 #include "CommandRequestedEvent.h"
+#include "DisplayName.h"
 #include "DynamicBodyComponent.h"
 #include "EntityAdmin.h"
-#include "EntitySelectedEvent.h"
+#include "EntitySelectionChangedEvent.h"
 #include "EventManager.h"
 #include "FactionComponent.h"
 #include "HealthComponent.h"
@@ -196,6 +198,11 @@ SelectedBuildingPanel::SelectedBuildingPanel(Simulation* sim,
     m_layout->addWidget(m_stationStatsLabel);
     m_stationStatsLabel->hide();
 
+    m_entitySummaryLabel = new QLabel(this);
+    m_entitySummaryLabel->setWordWrap(true);
+    m_layout->addWidget(m_entitySummaryLabel);
+    m_entitySummaryLabel->hide();
+
     m_scrapLabel = new QLabel(this);
     m_layout->addWidget(m_scrapLabel);
     m_scrapLabel->hide();
@@ -215,8 +222,9 @@ void SelectedBuildingPanel::onSelectionChanged(const std::vector<BuildingId>& id
     m_selectedBuildingIds = ids;
     if (!ids.empty())
     {
+        // A building selection is exclusive: it supersedes any field selection —
+        // actors and scrap (REQ-UI-SELECTION-CATEGORIES).
         clearEntityDisplay();
-        // A building selection supersedes any scrap selection (REQ-UI-SCRAP-CLICK-SELECT).
         m_selectedScrap.clear();
         m_scrapLabel->hide();
     }
@@ -266,6 +274,7 @@ void SelectedBuildingPanel::buildEmpty()
     m_entityTitleLabel->hide();
     m_entityStatsPanel->hide();
     m_stationStatsLabel->hide();
+    m_entitySummaryLabel->hide();
 }
 
 void SelectedBuildingPanel::buildSingle(BuildingId id)
@@ -658,16 +667,24 @@ void SelectedBuildingPanel::handleEvent(
 
 void SelectedBuildingPanel::refreshSelectionDisplay(RefreshReason reason)
 {
-    if (!m_selectedScrap.empty())
+    if (!m_selectedEntities.empty() || !m_selectedScrap.empty())
     {
-        // The total shrinks live as piles are collected or despawn (REQ-UI-SCRAP-PANEL).
-        refreshScrapTotal();
-        return;
-    }
-
-    if (m_selectedEntity.has_value())
-    {
-        refreshEntityStats();
+        // Field selection. Keep the live values current: the single-actor stats panel,
+        // the standalone scrap total, or the count summary (whose scrap line shrinks as
+        // piles are collected) — matching the layout chosen by buildFieldSelection()
+        // (REQ-UI-SHIP-STATS-PANEL, REQ-UI-SCRAP-PANEL).
+        if (m_selectedEntities.size() == 1 && m_selectedScrap.empty())
+        {
+            refreshEntityStats();
+        }
+        else if (m_selectedEntities.empty())
+        {
+            refreshScrapTotal();
+        }
+        else
+        {
+            buildEntitySummary();
+        }
         return;
     }
 
@@ -737,7 +754,7 @@ void SelectedBuildingPanel::buildMulti(const std::vector<BuildingId>& ids)
     QString text;
     for (const std::pair<const BuildingType, int>& entry : counts)
     {
-        text += buildingTypeName(entry.first) + ": "
+        text += buildingTypeName(entry.first) + " x "
             + QString::number(entry.second) + "\n";
         if (isBeltLike(entry.first))
         {
@@ -906,39 +923,139 @@ void SelectedBuildingPanel::onClearBelt()
     }
 }
 
-void SelectedBuildingPanel::handleEvent(std::shared_ptr<const EntitySelectedEvent> event)
+void SelectedBuildingPanel::handleEvent(std::shared_ptr<const EntitySelectionChangedEvent> event)
 {
-    if (event->entity.has_value())
+    m_selectedEntities = event->entities;
+    if (!m_selectedEntities.empty())
     {
-        m_selectedEntity = event->entity;
+        // A field selection supersedes any building selection (REQ-UI-SELECTION-CATEGORIES).
         m_selectedBuildingIds.clear();
-        // An entity selection supersedes any scrap selection (REQ-UI-SCRAP-CLICK-SELECT).
-        m_selectedScrap.clear();
+    }
+    buildFieldSelection();
+}
+
+void SelectedBuildingPanel::buildFieldSelection()
+{
+    if (m_selectedEntities.empty() && m_selectedScrap.empty())
+    {
+        // Nothing in the field category. Fall back to empty unless buildings own the panel.
+        clearEntityDisplay();
         m_scrapLabel->hide();
-        clearContent();
-
-        EntityAdmin& admin = m_sim->getAdmin();
-        entt::entity entity = *m_selectedEntity;
-
-        if (!admin.isValid(entity))
+        if (m_selectedBuildingIds.empty())
         {
-            clearEntityDisplay();
-            return;
+            buildEmpty();
         }
+        return;
+    }
 
-        if (admin.hasAll<ShipIdentityComponent>(entity))
+    // A field selection owns the panel: drop any building content.
+    clearContent();
+
+    EntityAdmin& admin = m_sim->getAdmin();
+
+    // Full single-actor stats are shown only for a lone actor with no scrap. As soon as
+    // the selection holds more than one object (multiple actors, or an actor plus scrap),
+    // the panel switches to the compact count summary (REQ-UI-FIELD-MULTI-SELECTION).
+    if (m_selectedEntities.size() == 1 && m_selectedScrap.empty())
+    {
+        m_entitySummaryLabel->hide();
+        m_scrapLabel->hide();
+        const entt::entity entity = m_selectedEntities.front();
+        if (admin.isValid(entity) && admin.hasAll<ShipIdentityComponent>(entity))
         {
             buildEntityShip(entity);
         }
-        else if (admin.hasAll<StationBodyComponent>(entity))
+        else if (admin.isValid(entity) && admin.hasAll<StationBodyComponent>(entity))
         {
             buildEntityStation(entity);
         }
+        else
+        {
+            m_entityTitleLabel->hide();
+            m_entityStatsPanel->hide();
+            m_stationStatsLabel->hide();
+        }
+        return;
     }
-    else
+
+    m_entityTitleLabel->hide();
+    m_entityStatsPanel->hide();
+    m_stationStatsLabel->hide();
+
+    if (m_selectedEntities.empty())
     {
-        clearEntityDisplay();
+        // Scrap only: a single "Scrap: N" line.
+        m_entitySummaryLabel->hide();
+        refreshScrapTotal();
+        m_scrapLabel->show();
+        return;
     }
+
+    // Actor counts, with the scrap total appended into the same label so every line
+    // shares the same spacing.
+    m_scrapLabel->hide();
+    buildEntitySummary();
+}
+
+void SelectedBuildingPanel::buildEntitySummary()
+{
+    EntityAdmin& admin = m_sim->getAdmin();
+
+    // Group actors by faction + kind + ship schematic, preserving first-seen order
+    // (REQ-UI-FIELD-MULTI-SELECTION).
+    std::vector<QString> keys;
+    std::map<QString, int> counts;
+    std::map<QString, QString> labels;
+
+    for (entt::entity entity : m_selectedEntities)
+    {
+        if (!admin.isValid(entity)) { continue; }
+        const bool isEnemy = admin.hasAll<FactionComponent>(entity)
+            && admin.get<FactionComponent>(entity).isEnemy;
+
+        QString key;
+        QString label;
+        if (admin.hasAll<ShipIdentityComponent>(entity))
+        {
+            const std::string& id = admin.get<ShipIdentityComponent>(entity).schematicId;
+            const QString name = QString::fromStdString(toDisplayName(id));
+            key = (isEnemy ? QStringLiteral("ship:enemy:") : QStringLiteral("ship:player:"))
+                + QString::fromStdString(id);
+            label = isEnemy ? tr("Enemy %1").arg(name) : name;
+        }
+        else if (admin.hasAll<StationBodyComponent>(entity))
+        {
+            key = isEnemy ? QStringLiteral("station:enemy") : QStringLiteral("station:player");
+            label = isEnemy ? tr("Enemy Defence Station") : tr("Player Defence Station");
+        }
+        else
+        {
+            continue;
+        }
+
+        if (counts.find(key) == counts.end())
+        {
+            keys.push_back(key);
+            labels[key] = label;
+        }
+        counts[key] += 1;
+    }
+
+    // One "<type> x <count>" line per group (matching the recipe tooltip and the building
+    // multi-selection). No total-count header, consistent with the building panel. The
+    // scrap total, when present, is appended as another line in the same label so the
+    // line spacing is uniform (REQ-UI-FIELD-MULTI-SELECTION, REQ-UI-SCRAP-PANEL).
+    QStringList lines;
+    for (const QString& key : keys)
+    {
+        lines << tr("%1 x %2").arg(labels[key]).arg(counts[key]);
+    }
+    if (!m_selectedScrap.empty())
+    {
+        lines << scrapTotalText();
+    }
+    m_entitySummaryLabel->setText(lines.join('\n'));
+    m_entitySummaryLabel->show();
 }
 
 void SelectedBuildingPanel::buildEntityShip(entt::entity entity)
@@ -1016,23 +1133,17 @@ void SelectedBuildingPanel::buildEntityStation(entt::entity entity)
 
 void SelectedBuildingPanel::refreshEntityStats()
 {
-    if (!m_selectedEntity.has_value()) { return; }
+    // Only the single-actor stats panel needs a live refresh; the multi-actor summary is
+    // static counts, and GameWorldView prunes dead/despawned actors and re-emits the
+    // selection (REQ-UI-ENTITY-CLICK-SELECT), so the panel does not mutate it here.
+    if (m_selectedEntities.size() != 1) { return; }
 
     EntityAdmin& admin = m_sim->getAdmin();
-    entt::entity entity = *m_selectedEntity;
-
-    if (!admin.isValid(entity))
-    {
-        clearEntityDisplay();
-        return;
-    }
+    const entt::entity entity = m_selectedEntities.front();
 
+    if (!admin.isValid(entity) || !admin.hasAll<HealthComponent>(entity)) { return; }
     const HealthComponent& health = admin.get<HealthComponent>(entity);
-    if (health.hp <= 0.0f)
-    {
-        clearEntityDisplay();
-        return;
-    }
+    if (health.hp <= 0.0f) { return; }
 
     if (admin.hasAll<ShipIdentityComponent>(entity))
     {
@@ -1049,10 +1160,11 @@ void SelectedBuildingPanel::refreshEntityStats()
 
 void SelectedBuildingPanel::clearEntityDisplay()
 {
-    m_selectedEntity = std::nullopt;
+    m_selectedEntities.clear();
     m_entityTitleLabel->hide();
     m_entityStatsPanel->hide();
     m_stationStatsLabel->hide();
+    m_entitySummaryLabel->hide();
 }
 
 void SelectedBuildingPanel::handleEvent(std::shared_ptr<const SelectionChangedEvent> event)
@@ -1066,34 +1178,14 @@ void SelectedBuildingPanel::handleEvent(
     m_selectedScrap = event->scrap;
     if (!m_selectedScrap.empty())
     {
-        // Scrap is its own selection category, mutually exclusive with buildings and
-        // entities (REQ-UI-SCRAP-CLICK-SELECT).
+        // Scrap is a field object: it supersedes any building selection but coexists
+        // with actors (REQ-UI-SELECTION-CATEGORIES).
         m_selectedBuildingIds.clear();
-        clearContent();
-        clearEntityDisplay();
-        buildScrap();
-    }
-    else
-    {
-        m_scrapLabel->hide();
-        if (m_selectedBuildingIds.empty() && !m_selectedEntity.has_value())
-        {
-            buildEmpty();
-        }
     }
+    buildFieldSelection();
 }
 
-void SelectedBuildingPanel::buildScrap()
-{
-    clearContent();
-    m_entityTitleLabel->hide();
-    m_entityStatsPanel->hide();
-    m_stationStatsLabel->hide();
-    refreshScrapTotal();
-    m_scrapLabel->show();
-}
-
-void SelectedBuildingPanel::refreshScrapTotal()
+QString SelectedBuildingPanel::scrapTotalText() const
 {
     // Sum the remaining amounts of the still-living selected piles (REQ-UI-SCRAP-PANEL).
     int total = 0;
@@ -1105,7 +1197,12 @@ void SelectedBuildingPanel::refreshScrapTotal()
             total += info.amount;
         }
     }
-    m_scrapLabel->setText(tr("Scrap: %1").arg(total));
+    return tr("Scrap x %1").arg(total);
+}
+
+void SelectedBuildingPanel::refreshScrapTotal()
+{
+    m_scrapLabel->setText(scrapTotalText());
 }
 
 void SelectedBuildingPanel::handleEvent(std::shared_ptr<const DebugDrawToggledEvent> event)

src/ui/SelectedBuildingPanel.h

@@ -13,7 +13,7 @@
 #include "Building.h"
 #include "BuildingId.h"
 #include "DebugDrawToggledEvent.h"
-#include "EntitySelectedEvent.h"
+#include "EntitySelectionChangedEvent.h"
 #include "EventHandler.h"
 #include "GameConfig.h"
 #include "PlayerCommandsAppliedEvent.h"
@@ -36,7 +36,7 @@ class QVBoxLayout;
 class SelectedBuildingPanel : public QWidget,
                                public CombinedEventHandler<TickAdvancedEvent,
                                                            PlayerCommandsAppliedEvent,
-                                                           EntitySelectedEvent,
+                                                           EntitySelectionChangedEvent,
                                                            SelectionChangedEvent,
                                                            ScrapSelectionChangedEvent,
                                                            DebugDrawToggledEvent>
@@ -51,7 +51,7 @@ public:
 private:
     void handleEvent(std::shared_ptr<const TickAdvancedEvent> event) override;
     void handleEvent(std::shared_ptr<const PlayerCommandsAppliedEvent> event) override;
-    void handleEvent(std::shared_ptr<const EntitySelectedEvent> event) override;
+    void handleEvent(std::shared_ptr<const EntitySelectionChangedEvent> event) override;
     void handleEvent(std::shared_ptr<const SelectionChangedEvent> event) override;
     void handleEvent(std::shared_ptr<const ScrapSelectionChangedEvent> event) override;
     void handleEvent(std::shared_ptr<const DebugDrawToggledEvent> event) override;
@@ -80,8 +80,9 @@ private:
     void buildEmpty();
     void buildSingle(BuildingId id);
     void buildMulti(const std::vector<BuildingId>& ids);
-    void buildScrap();
     void refreshScrapTotal();
+    // "Scrap: N" for the summed remaining amount of the selected piles (REQ-UI-SCRAP-PANEL).
+    QString scrapTotalText() const;
     void refreshBuffers(const Building* b);
     void refreshSiteProgress(const ConstructionSite* s);
     void updateShipyardLayoutWidgets(BuildingType type,
@@ -115,16 +116,24 @@ private:
     std::string  m_currentRecipeId;
 
     bool m_debugDraw = false;
-    std::optional<entt::entity> m_selectedEntity;
+    // The selected ships/defence stations. Shares the "field" selection category with
+    // scrap (m_selectedScrap): both can be non-empty at once (REQ-UI-SELECTION-CATEGORIES).
+    std::vector<entt::entity> m_selectedEntities;
     ShipStatsPanel* m_entityStatsPanel;
     QLabel*         m_entityTitleLabel;
     QLabel*         m_stationStatsLabel;
+    QLabel*         m_entitySummaryLabel;
 
     std::vector<entt::entity> m_selectedScrap;
     QLabel*                   m_scrapLabel;
 
+    // Renders the combined field selection (actors + scrap): a single-actor stats panel
+    // or a multi-actor summary, plus the scrap total when scrap is also selected
+    // (REQ-UI-FIELD-MULTI-SELECTION).
+    void buildFieldSelection();
     void buildEntityShip(entt::entity entity);
     void buildEntityStation(entt::entity entity);
+    void buildEntitySummary();
     void refreshEntityStats();
     void clearEntityDisplay();
 };