799 lines
24 KiB
C++
799 lines
24 KiB
C++
#include "ShipLayoutDialog.h"
|
|
|
|
#include <cctype>
|
|
#include <functional>
|
|
|
|
#include <QGridLayout>
|
|
#include <QHBoxLayout>
|
|
#include <QInputDialog>
|
|
#include <QKeyEvent>
|
|
#include <QMouseEvent>
|
|
#include <QPainter>
|
|
#include <QPushButton>
|
|
#include <QScrollArea>
|
|
#include <QSignalMapper>
|
|
#include <QVBoxLayout>
|
|
|
|
namespace
|
|
{
|
|
|
|
const int kCellSize = 32;
|
|
|
|
QString displayName(const std::string& id)
|
|
{
|
|
QString result;
|
|
bool nextUpper = true;
|
|
for (char c : id)
|
|
{
|
|
if (c == '_')
|
|
{
|
|
result += ' ';
|
|
nextUpper = true;
|
|
}
|
|
else if (nextUpper)
|
|
{
|
|
result += static_cast<char>(std::toupper(static_cast<unsigned char>(c)));
|
|
nextUpper = false;
|
|
}
|
|
else
|
|
{
|
|
result += c;
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
std::vector<std::string> rotateMaskCW(const std::vector<std::string>& grid)
|
|
{
|
|
if (grid.empty())
|
|
{
|
|
return {};
|
|
}
|
|
const int srcH = static_cast<int>(grid.size());
|
|
int srcW = 0;
|
|
for (const std::string& row : grid)
|
|
{
|
|
const int w = static_cast<int>(row.size());
|
|
if (w > srcW)
|
|
{
|
|
srcW = w;
|
|
}
|
|
}
|
|
const int dstW = srcH;
|
|
const int dstH = srcW;
|
|
std::vector<std::string> dst(dstH, std::string(dstW, 'X'));
|
|
for (int row = 0; row < srcH; ++row)
|
|
{
|
|
for (int col = 0; col < srcW; ++col)
|
|
{
|
|
const char ch = (col < static_cast<int>(grid[row].size()))
|
|
? grid[row][col]
|
|
: 'X';
|
|
dst[col][srcH - 1 - row] = ch;
|
|
}
|
|
}
|
|
return dst;
|
|
}
|
|
|
|
} // namespace
|
|
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// Grid rendering widget (nested inside dialog)
|
|
// ---------------------------------------------------------------------------
|
|
|
|
class LayoutGridWidget : public QWidget
|
|
{
|
|
public:
|
|
LayoutGridWidget(ShipLayoutDialog* dialog, QWidget* parent = nullptr)
|
|
: QWidget(parent)
|
|
, m_dialog(dialog)
|
|
{
|
|
setMouseTracking(true);
|
|
}
|
|
|
|
void setGridData(const std::vector<std::vector<ShipLayoutDialog::CellInfo>>* grid,
|
|
int rows, int cols,
|
|
const std::vector<PlacedModule>* placed,
|
|
const GameConfig* config)
|
|
{
|
|
m_grid = grid;
|
|
m_rows = rows;
|
|
m_cols = cols;
|
|
m_placed = placed;
|
|
m_config = config;
|
|
setFixedSize(cols * kCellSize + 1, rows * kCellSize + 1);
|
|
}
|
|
|
|
void setGhostData(int moduleIndex, Rotation rotation)
|
|
{
|
|
m_ghostModuleIdx = moduleIndex;
|
|
m_ghostRotation = rotation;
|
|
}
|
|
|
|
protected:
|
|
void paintEvent(QPaintEvent* /*event*/) override
|
|
{
|
|
if (!m_grid || m_rows == 0 || m_cols == 0)
|
|
{
|
|
return;
|
|
}
|
|
|
|
QPainter painter(this);
|
|
painter.setRenderHint(QPainter::Antialiasing, false);
|
|
|
|
for (int r = 0; r < m_rows; ++r)
|
|
{
|
|
for (int c = 0; c < m_cols; ++c)
|
|
{
|
|
const QRect cellRect(c * kCellSize, r * kCellSize, kCellSize, kCellSize);
|
|
const ShipLayoutDialog::CellInfo& cell = (*m_grid)[r][c];
|
|
|
|
if (!cell.buildable)
|
|
{
|
|
painter.fillRect(cellRect, QColor(30, 30, 30));
|
|
}
|
|
else if (cell.moduleIndex >= 0)
|
|
{
|
|
const PlacedModule& pm = (*m_placed)[cell.moduleIndex];
|
|
const ModuleDef* def = findModule(pm.moduleId);
|
|
QColor color(Qt::gray);
|
|
QString glyph;
|
|
if (def)
|
|
{
|
|
color = QColor(QString::fromStdString(def->fillColor));
|
|
glyph = QString::fromStdString(def->glyph);
|
|
}
|
|
painter.fillRect(cellRect, color);
|
|
if (!glyph.isEmpty())
|
|
{
|
|
painter.setPen(Qt::white);
|
|
painter.drawText(cellRect, Qt::AlignCenter, glyph);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
painter.fillRect(cellRect, QColor(240, 240, 240));
|
|
}
|
|
|
|
painter.setPen(QColor(100, 100, 100));
|
|
painter.drawRect(cellRect);
|
|
}
|
|
}
|
|
|
|
// Draw ghost
|
|
if (m_ghostModuleIdx >= 0 && m_hoverCell.x() >= 0 && m_config)
|
|
{
|
|
const ModuleDef& def = m_config->modules.modules[m_ghostModuleIdx];
|
|
const std::vector<std::string> mask = rotateMask(def.surfaceMask, m_ghostRotation);
|
|
QColor ghostColor(QString::fromStdString(def.fillColor));
|
|
ghostColor.setAlpha(100);
|
|
|
|
for (int mr = 0; mr < static_cast<int>(mask.size()); ++mr)
|
|
{
|
|
for (int mc = 0; mc < static_cast<int>(mask[mr].size()); ++mc)
|
|
{
|
|
if (mask[mr][mc] != 'O')
|
|
{
|
|
continue;
|
|
}
|
|
const int gr = m_hoverCell.y() + mr;
|
|
const int gc = m_hoverCell.x() + mc;
|
|
if (gr >= 0 && gr < m_rows && gc >= 0 && gc < m_cols)
|
|
{
|
|
const QRect cellRect(gc * kCellSize, gr * kCellSize,
|
|
kCellSize, kCellSize);
|
|
painter.fillRect(cellRect, ghostColor);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void mouseMoveEvent(QMouseEvent* event) override
|
|
{
|
|
const QPoint pos = event->pos();
|
|
const QPoint cell(pos.x() / kCellSize, pos.y() / kCellSize);
|
|
if (cell != m_hoverCell)
|
|
{
|
|
m_hoverCell = cell;
|
|
update();
|
|
}
|
|
}
|
|
|
|
void mousePressEvent(QMouseEvent* event) override
|
|
{
|
|
if (event->button() != Qt::LeftButton)
|
|
{
|
|
return;
|
|
}
|
|
const QPoint pos = event->pos();
|
|
const QPoint cell(pos.x() / kCellSize, pos.y() / kCellSize);
|
|
emit m_dialog->gridCellClicked(cell);
|
|
}
|
|
|
|
void leaveEvent(QEvent* /*event*/) override
|
|
{
|
|
m_hoverCell = QPoint(-1, -1);
|
|
update();
|
|
}
|
|
|
|
private:
|
|
const ModuleDef* findModule(const std::string& id) const
|
|
{
|
|
if (!m_config)
|
|
{
|
|
return nullptr;
|
|
}
|
|
for (const ModuleDef& def : m_config->modules.modules)
|
|
{
|
|
if (def.id == id)
|
|
{
|
|
return &def;
|
|
}
|
|
}
|
|
return nullptr;
|
|
}
|
|
|
|
std::vector<std::string> rotateMask(const std::vector<std::string>& mask,
|
|
Rotation rotation) const
|
|
{
|
|
int steps = 0;
|
|
switch (rotation)
|
|
{
|
|
case Rotation::East: steps = 0; break;
|
|
case Rotation::South: steps = 1; break;
|
|
case Rotation::West: steps = 2; break;
|
|
case Rotation::North: steps = 3; break;
|
|
}
|
|
std::vector<std::string> result = mask;
|
|
for (int i = 0; i < steps; ++i)
|
|
{
|
|
result = rotateMaskCW(result);
|
|
}
|
|
return result;
|
|
}
|
|
|
|
ShipLayoutDialog* m_dialog;
|
|
const std::vector<std::vector<ShipLayoutDialog::CellInfo>>* m_grid = nullptr;
|
|
int m_rows = 0;
|
|
int m_cols = 0;
|
|
const std::vector<PlacedModule>* m_placed = nullptr;
|
|
const GameConfig* m_config = nullptr;
|
|
int m_ghostModuleIdx = -2;
|
|
Rotation m_ghostRotation = Rotation::East;
|
|
QPoint m_hoverCell = QPoint(-1, -1);
|
|
};
|
|
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// Blueprint panel (third column of the layout dialog)
|
|
// ---------------------------------------------------------------------------
|
|
|
|
class ShipLayoutBlueprintPanel : public QWidget
|
|
{
|
|
public:
|
|
ShipLayoutBlueprintPanel(
|
|
std::vector<ShipLayoutBlueprint>& allBlueprints,
|
|
const std::string& shipType,
|
|
std::function<std::vector<PlacedModule>()> getModules,
|
|
std::function<void(const std::vector<PlacedModule>&)> loadModules,
|
|
QWidget* parent = nullptr)
|
|
: QWidget(parent)
|
|
, m_allBlueprints(allBlueprints)
|
|
, m_shipType(shipType)
|
|
, m_getModules(std::move(getModules))
|
|
, m_loadModules(std::move(loadModules))
|
|
{
|
|
QVBoxLayout* layout = new QVBoxLayout(this);
|
|
layout->setContentsMargins(4, 4, 4, 4);
|
|
layout->setSpacing(4);
|
|
|
|
QPushButton* createBtn = new QPushButton(tr("Create Blueprint"), this);
|
|
createBtn->setFixedHeight(36);
|
|
layout->addWidget(createBtn);
|
|
|
|
m_scrollArea = new QScrollArea(this);
|
|
m_scrollArea->setWidgetResizable(true);
|
|
m_scrollArea->setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
|
|
|
|
m_scrollContainer = new QWidget(m_scrollArea);
|
|
m_listLayout = new QVBoxLayout(m_scrollContainer);
|
|
m_listLayout->setContentsMargins(0, 0, 0, 0);
|
|
m_listLayout->setSpacing(2);
|
|
m_listLayout->addStretch();
|
|
m_scrollArea->setWidget(m_scrollContainer);
|
|
layout->addWidget(m_scrollArea, 1);
|
|
|
|
connect(createBtn, &QPushButton::clicked, this, [this]() {
|
|
bool ok = false;
|
|
const QString name = QInputDialog::getText(
|
|
this, tr("Create Blueprint"), tr("Blueprint name:"),
|
|
QLineEdit::Normal, QString(), &ok);
|
|
if (!ok || name.trimmed().isEmpty()) { return; }
|
|
|
|
ShipLayoutBlueprint bp;
|
|
bp.name = name.trimmed();
|
|
bp.shipType = m_shipType;
|
|
bp.modules = m_getModules();
|
|
m_allBlueprints.push_back(std::move(bp));
|
|
rebuildList();
|
|
});
|
|
|
|
rebuildList();
|
|
}
|
|
|
|
private:
|
|
void rebuildList()
|
|
{
|
|
// Remove all items except the trailing stretch.
|
|
while (m_listLayout->count() > 1)
|
|
{
|
|
QLayoutItem* item = m_listLayout->takeAt(0);
|
|
if (item->widget()) { delete item->widget(); }
|
|
delete item;
|
|
}
|
|
|
|
for (std::size_t i = 0; i < m_allBlueprints.size(); ++i)
|
|
{
|
|
const ShipLayoutBlueprint& bp = m_allBlueprints[i];
|
|
if (bp.shipType != m_shipType) { continue; }
|
|
|
|
QWidget* row = new QWidget(m_scrollContainer);
|
|
QHBoxLayout* rowLayout = new QHBoxLayout(row);
|
|
rowLayout->setContentsMargins(0, 0, 0, 0);
|
|
rowLayout->setSpacing(2);
|
|
|
|
QPushButton* nameBtn = new QPushButton(bp.name, row);
|
|
nameBtn->setFixedHeight(36);
|
|
|
|
QPushButton* delBtn = new QPushButton("\xc3\x97", row);
|
|
delBtn->setFixedWidth(28);
|
|
delBtn->setFixedHeight(36);
|
|
|
|
rowLayout->addWidget(nameBtn, 1);
|
|
rowLayout->addWidget(delBtn, 0);
|
|
m_listLayout->insertWidget(m_listLayout->count() - 1, row);
|
|
|
|
const std::vector<PlacedModule> modules = bp.modules;
|
|
connect(nameBtn, &QPushButton::clicked, this, [this, modules]() {
|
|
m_loadModules(modules);
|
|
});
|
|
|
|
connect(delBtn, &QPushButton::clicked, this, [this, i]() {
|
|
m_allBlueprints.erase(m_allBlueprints.begin()
|
|
+ static_cast<std::ptrdiff_t>(i));
|
|
rebuildList();
|
|
});
|
|
}
|
|
}
|
|
|
|
std::vector<ShipLayoutBlueprint>& m_allBlueprints;
|
|
std::string m_shipType;
|
|
std::function<std::vector<PlacedModule>()> m_getModules;
|
|
std::function<void(const std::vector<PlacedModule>&)> m_loadModules;
|
|
QScrollArea* m_scrollArea = nullptr;
|
|
QWidget* m_scrollContainer = nullptr;
|
|
QVBoxLayout* m_listLayout = nullptr;
|
|
};
|
|
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// ShipLayoutDialog implementation
|
|
// ---------------------------------------------------------------------------
|
|
|
|
ShipLayoutDialog::ShipLayoutDialog(const GameConfig* config,
|
|
const std::string& shipId,
|
|
const ShipLayoutConfig& currentLayout,
|
|
std::vector<ShipLayoutBlueprint>& allBlueprints,
|
|
QWidget* parent)
|
|
: QDialog(parent)
|
|
, m_config(config)
|
|
, m_shipId(shipId)
|
|
, m_rows(0)
|
|
, m_cols(0)
|
|
, m_placedModules(currentLayout.placedModules)
|
|
, m_activeModuleIndex(-2)
|
|
, m_currentRotation(Rotation::East)
|
|
, m_removeButton(nullptr)
|
|
, m_gridWidget(nullptr)
|
|
{
|
|
setWindowTitle(tr("Configure Ship Layout"));
|
|
setModal(true);
|
|
|
|
// Find the ship's layout grid.
|
|
for (const ShipDef& def : config->ships.ships)
|
|
{
|
|
if (def.id == shipId)
|
|
{
|
|
m_shipLayout = def.layout;
|
|
break;
|
|
}
|
|
}
|
|
|
|
m_rows = static_cast<int>(m_shipLayout.size());
|
|
m_cols = 0;
|
|
for (const std::string& row : m_shipLayout)
|
|
{
|
|
const int w = static_cast<int>(row.size());
|
|
if (w > m_cols)
|
|
{
|
|
m_cols = w;
|
|
}
|
|
}
|
|
|
|
// Initialize grid.
|
|
m_grid.assign(m_rows, std::vector<CellInfo>(m_cols, {false, -1}));
|
|
for (int r = 0; r < m_rows; ++r)
|
|
{
|
|
for (int c = 0; c < static_cast<int>(m_shipLayout[r].size()); ++c)
|
|
{
|
|
if (m_shipLayout[r][c] == 'O')
|
|
{
|
|
m_grid[r][c].buildable = true;
|
|
}
|
|
}
|
|
}
|
|
rebuildOccupancy();
|
|
|
|
// --- UI layout ---
|
|
QHBoxLayout* mainLayout = new QHBoxLayout(this);
|
|
|
|
// Left: grid widget.
|
|
LayoutGridWidget* gridW = new LayoutGridWidget(this, this);
|
|
gridW->setGridData(&m_grid, m_rows, m_cols, &m_placedModules, m_config);
|
|
gridW->setGhostData(m_activeModuleIndex, m_currentRotation);
|
|
m_gridWidget = gridW;
|
|
mainLayout->addWidget(m_gridWidget);
|
|
|
|
// Right: module buttons + confirm/cancel.
|
|
QVBoxLayout* rightLayout = new QVBoxLayout();
|
|
|
|
QGridLayout* buttonGrid = new QGridLayout();
|
|
buttonGrid->setSpacing(4);
|
|
|
|
QSignalMapper* mapper = new QSignalMapper(this);
|
|
int col = 0;
|
|
int row = 0;
|
|
const int kCols = 2;
|
|
|
|
for (int i = 0; i < static_cast<int>(config->modules.modules.size()); ++i)
|
|
{
|
|
const ModuleDef& def = config->modules.modules[i];
|
|
const QString label = displayName(def.id)
|
|
+ "\n" + QString::fromStdString(def.glyph);
|
|
QPushButton* btn = new QPushButton(label, this);
|
|
btn->setCheckable(true);
|
|
btn->setFixedHeight(48);
|
|
buttonGrid->addWidget(btn, row, col);
|
|
m_moduleButtons.push_back(btn);
|
|
|
|
mapper->setMapping(btn, i);
|
|
connect(btn, &QPushButton::clicked, mapper, qOverload<>(&QSignalMapper::map));
|
|
|
|
++col;
|
|
if (col >= kCols)
|
|
{
|
|
col = 0;
|
|
++row;
|
|
}
|
|
}
|
|
connect(mapper, qOverload<int>(&QSignalMapper::mapped),
|
|
this, &ShipLayoutDialog::onModuleButtonClicked);
|
|
|
|
// Remove button.
|
|
m_removeButton = new QPushButton(tr("Remove"), this);
|
|
m_removeButton->setCheckable(true);
|
|
m_removeButton->setFixedHeight(48);
|
|
if (col > 0)
|
|
{
|
|
++row;
|
|
}
|
|
buttonGrid->addWidget(m_removeButton, row, 0, 1, kCols);
|
|
connect(m_removeButton, &QPushButton::clicked, this, [this]() {
|
|
if (m_activeModuleIndex == -1)
|
|
{
|
|
m_activeModuleIndex = -2;
|
|
m_removeButton->setChecked(false);
|
|
}
|
|
else
|
|
{
|
|
for (QPushButton* btn : m_moduleButtons)
|
|
{
|
|
btn->setChecked(false);
|
|
}
|
|
m_activeModuleIndex = -1;
|
|
m_removeButton->setChecked(true);
|
|
}
|
|
updateGridWidget();
|
|
});
|
|
|
|
rightLayout->addLayout(buttonGrid);
|
|
rightLayout->addStretch();
|
|
|
|
// Confirm / Cancel buttons.
|
|
QHBoxLayout* bottomBar = new QHBoxLayout();
|
|
QPushButton* confirmBtn = new QPushButton(tr("Confirm"), this);
|
|
QPushButton* cancelBtn = new QPushButton(tr("Cancel"), this);
|
|
bottomBar->addWidget(confirmBtn);
|
|
bottomBar->addWidget(cancelBtn);
|
|
rightLayout->addLayout(bottomBar);
|
|
|
|
connect(confirmBtn, &QPushButton::clicked, this, &ShipLayoutDialog::onConfirm);
|
|
connect(cancelBtn, &QPushButton::clicked, this, &ShipLayoutDialog::onCancel);
|
|
|
|
mainLayout->addLayout(rightLayout);
|
|
|
|
// Right: blueprint panel (third column).
|
|
ShipLayoutBlueprintPanel* bpPanel = new ShipLayoutBlueprintPanel(
|
|
allBlueprints,
|
|
m_shipId,
|
|
[this]() { return m_placedModules; },
|
|
[this](const std::vector<PlacedModule>& mods) { loadLayoutBlueprint(mods); },
|
|
this);
|
|
mainLayout->addWidget(bpPanel);
|
|
|
|
// Grid click handler.
|
|
connect(this, &ShipLayoutDialog::gridCellClicked, this, [this](QPoint cell) {
|
|
if (m_activeModuleIndex == -2)
|
|
{
|
|
return;
|
|
}
|
|
|
|
if (m_activeModuleIndex == -1)
|
|
{
|
|
// Remove mode: find and remove module at cell.
|
|
if (cell.y() >= 0 && cell.y() < m_rows && cell.x() >= 0 && cell.x() < m_cols)
|
|
{
|
|
const int idx = m_grid[cell.y()][cell.x()].moduleIndex;
|
|
if (idx >= 0)
|
|
{
|
|
m_placedModules.erase(m_placedModules.begin() + idx);
|
|
rebuildOccupancy();
|
|
updateGridWidget();
|
|
}
|
|
}
|
|
return;
|
|
}
|
|
|
|
// Place module.
|
|
const ModuleDef& def = m_config->modules.modules[m_activeModuleIndex];
|
|
if (canPlaceModule(def, cell, m_currentRotation))
|
|
{
|
|
PlacedModule pm;
|
|
pm.moduleId = def.id;
|
|
pm.position = cell;
|
|
pm.rotation = m_currentRotation;
|
|
m_placedModules.push_back(pm);
|
|
rebuildOccupancy();
|
|
updateGridWidget();
|
|
}
|
|
});
|
|
}
|
|
|
|
std::optional<ShipLayoutConfig> ShipLayoutDialog::result() const
|
|
{
|
|
return m_result;
|
|
}
|
|
|
|
void ShipLayoutDialog::keyPressEvent(QKeyEvent* event)
|
|
{
|
|
if (event->key() == Qt::Key_Q)
|
|
{
|
|
// Rotate CCW = 3 CW steps.
|
|
switch (m_currentRotation)
|
|
{
|
|
case Rotation::East: m_currentRotation = Rotation::North; break;
|
|
case Rotation::North: m_currentRotation = Rotation::West; break;
|
|
case Rotation::West: m_currentRotation = Rotation::South; break;
|
|
case Rotation::South: m_currentRotation = Rotation::East; break;
|
|
}
|
|
updateGridWidget();
|
|
}
|
|
else if (event->key() == Qt::Key_E)
|
|
{
|
|
// Rotate CW.
|
|
switch (m_currentRotation)
|
|
{
|
|
case Rotation::East: m_currentRotation = Rotation::South; break;
|
|
case Rotation::South: m_currentRotation = Rotation::West; break;
|
|
case Rotation::West: m_currentRotation = Rotation::North; break;
|
|
case Rotation::North: m_currentRotation = Rotation::East; break;
|
|
}
|
|
updateGridWidget();
|
|
}
|
|
else
|
|
{
|
|
QDialog::keyPressEvent(event);
|
|
}
|
|
}
|
|
|
|
void ShipLayoutDialog::onModuleButtonClicked(int index)
|
|
{
|
|
if (m_activeModuleIndex == index)
|
|
{
|
|
m_moduleButtons[index]->setChecked(false);
|
|
m_activeModuleIndex = -2;
|
|
}
|
|
else
|
|
{
|
|
for (int i = 0; i < static_cast<int>(m_moduleButtons.size()); ++i)
|
|
{
|
|
m_moduleButtons[i]->setChecked(i == index);
|
|
}
|
|
m_removeButton->setChecked(false);
|
|
m_activeModuleIndex = index;
|
|
}
|
|
updateGridWidget();
|
|
}
|
|
|
|
void ShipLayoutDialog::onConfirm()
|
|
{
|
|
ShipLayoutConfig layout;
|
|
layout.placedModules = m_placedModules;
|
|
m_result = layout;
|
|
accept();
|
|
}
|
|
|
|
void ShipLayoutDialog::onCancel()
|
|
{
|
|
m_result = std::nullopt;
|
|
reject();
|
|
}
|
|
|
|
void ShipLayoutDialog::rebuildOccupancy()
|
|
{
|
|
for (int r = 0; r < m_rows; ++r)
|
|
{
|
|
for (int c = 0; c < m_cols; ++c)
|
|
{
|
|
m_grid[r][c].moduleIndex = -1;
|
|
}
|
|
}
|
|
|
|
for (int i = 0; i < static_cast<int>(m_placedModules.size()); ++i)
|
|
{
|
|
const PlacedModule& pm = m_placedModules[i];
|
|
const ModuleDef* def = nullptr;
|
|
for (const ModuleDef& d : m_config->modules.modules)
|
|
{
|
|
if (d.id == pm.moduleId) { def = &d; break; }
|
|
}
|
|
if (!def)
|
|
{
|
|
continue;
|
|
}
|
|
const std::vector<std::string> mask = rotatedMask(*def, pm.rotation);
|
|
for (int mr = 0; mr < static_cast<int>(mask.size()); ++mr)
|
|
{
|
|
for (int mc = 0; mc < static_cast<int>(mask[mr].size()); ++mc)
|
|
{
|
|
if (mask[mr][mc] != 'O')
|
|
{
|
|
continue;
|
|
}
|
|
const int gr = pm.position.y() + mr;
|
|
const int gc = pm.position.x() + mc;
|
|
if (gr >= 0 && gr < m_rows && gc >= 0 && gc < m_cols)
|
|
{
|
|
m_grid[gr][gc].moduleIndex = i;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void ShipLayoutDialog::updateGridWidget()
|
|
{
|
|
LayoutGridWidget* gridW = static_cast<LayoutGridWidget*>(m_gridWidget);
|
|
gridW->setGhostData(m_activeModuleIndex, m_currentRotation);
|
|
gridW->update();
|
|
}
|
|
|
|
bool ShipLayoutDialog::canPlaceModule(const ModuleDef& def, QPoint position,
|
|
Rotation rotation) const
|
|
{
|
|
const std::vector<std::string> mask = rotatedMask(def, rotation);
|
|
for (int mr = 0; mr < static_cast<int>(mask.size()); ++mr)
|
|
{
|
|
for (int mc = 0; mc < static_cast<int>(mask[mr].size()); ++mc)
|
|
{
|
|
if (mask[mr][mc] != 'O')
|
|
{
|
|
continue;
|
|
}
|
|
const int gr = position.y() + mr;
|
|
const int gc = position.x() + mc;
|
|
if (gr < 0 || gr >= m_rows || gc < 0 || gc >= m_cols)
|
|
{
|
|
return false;
|
|
}
|
|
if (!m_grid[gr][gc].buildable)
|
|
{
|
|
return false;
|
|
}
|
|
if (m_grid[gr][gc].moduleIndex >= 0)
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
std::vector<std::string> ShipLayoutDialog::rotatedMask(const ModuleDef& def,
|
|
Rotation rotation) const
|
|
{
|
|
int steps = 0;
|
|
switch (rotation)
|
|
{
|
|
case Rotation::East: steps = 0; break;
|
|
case Rotation::South: steps = 1; break;
|
|
case Rotation::West: steps = 2; break;
|
|
case Rotation::North: steps = 3; break;
|
|
}
|
|
std::vector<std::string> result = def.surfaceMask;
|
|
for (int i = 0; i < steps; ++i)
|
|
{
|
|
result = rotateMaskCW(result);
|
|
}
|
|
return result;
|
|
}
|
|
|
|
void ShipLayoutDialog::loadLayoutBlueprint(const std::vector<PlacedModule>& modules)
|
|
{
|
|
m_placedModules.clear();
|
|
|
|
// Build a temporary occupancy grid to detect overlaps within the blueprint.
|
|
std::vector<std::vector<bool>> occupied(m_rows, std::vector<bool>(m_cols, false));
|
|
|
|
for (const PlacedModule& pm : modules)
|
|
{
|
|
// Validate module type exists.
|
|
const ModuleDef* def = nullptr;
|
|
for (const ModuleDef& d : m_config->modules.modules)
|
|
{
|
|
if (d.id == pm.moduleId) { def = &d; break; }
|
|
}
|
|
if (!def) { continue; }
|
|
|
|
const std::vector<std::string> mask = rotatedMask(*def, pm.rotation);
|
|
bool valid = true;
|
|
|
|
for (int mr = 0; mr < static_cast<int>(mask.size()) && valid; ++mr)
|
|
{
|
|
for (int mc = 0; mc < static_cast<int>(mask[mr].size()) && valid; ++mc)
|
|
{
|
|
if (mask[mr][mc] != 'O') { continue; }
|
|
const int gr = pm.position.y() + mr;
|
|
const int gc = pm.position.x() + mc;
|
|
if (gr < 0 || gr >= m_rows || gc < 0 || gc >= m_cols) { valid = false; break; }
|
|
if (!m_grid[gr][gc].buildable) { valid = false; break; }
|
|
if (occupied[gr][gc]) { valid = false; break; }
|
|
}
|
|
}
|
|
|
|
if (!valid) { continue; }
|
|
|
|
// Mark cells as occupied.
|
|
for (int mr = 0; mr < static_cast<int>(mask.size()); ++mr)
|
|
{
|
|
for (int mc = 0; mc < static_cast<int>(mask[mr].size()); ++mc)
|
|
{
|
|
if (mask[mr][mc] != 'O') { continue; }
|
|
const int gr = pm.position.y() + mr;
|
|
const int gc = pm.position.x() + mc;
|
|
if (gr >= 0 && gr < m_rows && gc >= 0 && gc < m_cols)
|
|
{
|
|
occupied[gr][gc] = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
m_placedModules.push_back(pm);
|
|
}
|
|
|
|
rebuildOccupancy();
|
|
updateGridWidget();
|
|
}
|