From e2933fc801393d15624731033ebfae65ff5420d0 Mon Sep 17 00:00:00 2001 From: Marcus Huderle Date: Tue, 6 Mar 2018 16:02:08 -0800 Subject: [PATCH 01/20] Add connections tab --- mainwindow.ui | 259 ++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 259 insertions(+) diff --git a/mainwindow.ui b/mainwindow.ui index 8aadf19d..d1faa64a 100755 --- a/mainwindow.ui +++ b/mainwindow.ui @@ -1199,6 +1199,265 @@ + + + Connections + + + + 0 + + + 0 + + + 0 + + + 0 + + + + + + 0 + 0 + + + + QFrame::StyledPanel + + + QFrame::Raised + + + + 0 + + + 0 + + + 0 + + + 0 + + + 0 + + + + + + 0 + 0 + + + + + 0 + 32 + + + + QFrame::StyledPanel + + + QFrame::Raised + + + + 4 + + + 4 + + + 4 + + + 4 + + + 4 + + + + + + North + + + + + East + + + + + South + + + + + West + + + + + + + + Qt::Horizontal + + + QSizePolicy::Fixed + + + + 20 + 20 + + + + + + + + Map + + + + + + + true + + + + + + + Qt::Horizontal + + + + 40 + 20 + + + + + + + + + + + QFrame::StyledPanel + + + QFrame::Raised + + + + 0 + + + 0 + + + 0 + + + 0 + + + 0 + + + + + true + + + + + 0 + 0 + 826 + 621 + + + + + + + + + + Qt::Vertical + + + + 20 + 40 + + + + + + + + Qt::Vertical + + + + 20 + 40 + + + + + + + + Qt::Horizontal + + + + 40 + 20 + + + + + + + + Qt::Horizontal + + + + 40 + 20 + + + + + + + + + + + + + + + + From 64007b5bae501ec3d4abf2f404c063b72cd498a4 Mon Sep 17 00:00:00 2001 From: Marcus Huderle Date: Wed, 7 Mar 2018 20:22:18 -0800 Subject: [PATCH 02/20] Add basic drop-and-drop connection editing --- editor.cpp | 142 ++++++++++++++++++++++++++++++++++++++++++++++++- editor.h | 35 ++++++++++++ mainwindow.cpp | 32 +++++++---- mainwindow.h | 6 +++ mainwindow.ui | 99 ++++++++-------------------------- map.h | 2 + project.cpp | 1 + 7 files changed, 229 insertions(+), 88 deletions(-) diff --git a/editor.cpp b/editor.cpp index ddca2fdd..675a3811 100755 --- a/editor.cpp +++ b/editor.cpp @@ -40,6 +40,7 @@ void Editor::setEditingMap() { map_item->draw(); map_item->setVisible(true); map_item->setEnabled(true); + setConnectionsVisibility(true); } if (collision_item) { collision_item->setVisible(false); @@ -52,8 +53,8 @@ void Editor::setEditingMap() { void Editor::setEditingCollision() { current_view = collision_item; if (collision_item) { - collision_item->draw(); collision_item->setVisible(true); + setConnectionsVisibility(true); } if (map_item) { map_item->setVisible(false); @@ -71,12 +72,88 @@ void Editor::setEditingObjects() { if (map_item) { map_item->setVisible(true); map_item->setEnabled(false); + setConnectionsVisibility(true); } if (collision_item) { collision_item->setVisible(false); } } +void Editor::setEditingConnections(QString direction) { + current_view = map_item; + if (map_item) { + map_item->draw(); + map_item->setVisible(true); + map_item->setEnabled(true); + setConnectionsVisibility(false); + showCurrentConnectionMap(direction); + } + if (collision_item) { + collision_item->setVisible(false); + } + if (objects_group) { + objects_group->setVisible(false); + } +} + +void Editor::showCurrentConnectionMap(QString curDirection) { + bool connectionExists = false; + for (Connection* connection : map->connections) { + if (connection->direction != curDirection) continue; + if (connection_item) { + scene->removeItem(connection_item); + delete connection_item; + connection_item = NULL; + } + + connectionExists = true; + Map *connected_map = project->getMap(connection->map_name); + QPixmap pixmap = connected_map->renderConnection(*connection); + int offset = connection->offset.toInt(nullptr, 0); + int x = 0, y = 0; + if (connection->direction == "up") { + x = offset * 16; + y = -pixmap.height(); + } else if (connection->direction == "down") { + x = offset * 16; + y = map->getHeight() * 16; + } else if (connection->direction == "left") { + x = -pixmap.width(); + y = offset * 16; + } else if (connection->direction == "right") { + x = map->getWidth() * 16; + y = offset * 16; + } + connection_item = new ConnectionPixmapItem(pixmap, connection, x, y); + connection_item->setX(x); + connection_item->setY(y); + connection_item->setZValue(21); + scene->addItem(connection_item); + scene->setSceneRect(0, 0, pixmap.width() + map_item->pixmap().width(), pixmap.height() + map_item->pixmap().height()); + + connect(connection_item, SIGNAL(connectionMoved(int)), this, SLOT(onConnectionOffsetChanged(int))); + onConnectionOffsetChanged(connection->offset.toInt()); + break; + } + + if (!connectionExists && connection_item) { + scene->removeItem(connection_item); + delete connection_item; + connection_item = NULL; + } +} + +void Editor::onConnectionOffsetChanged(int newOffset) { + emit connectionOffsetChanged(newOffset); +} + +void Editor::setConnectionsVisibility(bool visible) { + for (QGraphicsPixmapItem* item : map->connection_items) { + item->setVisible(visible); + item->setActive(visible); + } +} + void Editor::setMap(QString map_name) { if (map_name.isNull()) { return; @@ -231,6 +308,7 @@ void Editor::displayMapConnections() { item->setX(x); item->setY(y); scene->addItem(item); + map->connection_items.insert(connection->direction, item); } } @@ -263,6 +341,17 @@ void Editor::displayMapGrid() { } } +void Editor::updateConnectionOffset(int offset) { + connection_item->blockSignals(true); + connection_item->connection->offset = QString::number(offset); + if (connection_item->connection->direction == "up" || connection_item->connection->direction == "down") { + connection_item->setX(connection_item->initialX + (offset - connection_item->initialOffset) * 16); + } else { + connection_item->setY(connection_item->initialY + (offset - connection_item->initialOffset) * 16); + } + connection_item->blockSignals(false); +} + void MetatilesPixmapItem::paintTileChanged(Map *map) { draw(); } @@ -345,6 +434,57 @@ void CollisionMetatilesPixmapItem::updateCurHoveredMetatile(QPointF pos) { } } +QVariant ConnectionPixmapItem::itemChange(GraphicsItemChange change, const QVariant &value) +{ + if (change == ItemPositionChange) { + QPointF newPos = value.toPointF(); + + qreal x, y; + int newOffset = initialOffset; + if (connection->direction == "up" || connection->direction == "down") { + x = round(newPos.x() / 16) * 16; + newOffset += (x - initialX) / 16; + } + else { + x = initialX; + } + + if (connection->direction == "right" || connection->direction == "left") { + y = round(newPos.y() / 16) * 16; + newOffset += (y - initialY) / 16; + } + else { + y = initialY; + } + + emit connectionMoved(newOffset); + connection->offset = QString::number(newOffset); + return QPointF(x, y); + } + else { + return QGraphicsItem::itemChange(change, value); + } +} +void ConnectionPixmapItem::dragEnterEvent(QGraphicsSceneDragDropEvent *event) { + QPointF pos = event->pos(); + qDebug() << "enter: " << pos.x() << ", " << pos.y(); +} +void ConnectionPixmapItem::dragMoveEvent(QGraphicsSceneDragDropEvent *event) { + QPointF pos = event->pos(); + qDebug() << "drag: " << pos.x() << ", " << pos.y(); +} +void ConnectionPixmapItem::dragLeaveEvent(QGraphicsSceneDragDropEvent *event) { + QPointF pos = event->pos(); + qDebug() << "leave: " << pos.x() << ", " << pos.y(); +} +void ConnectionPixmapItem::dropEvent(QGraphicsSceneDragDropEvent *event) { + QPointF pos = event->pos(); + qDebug() << "drop: " << pos.x() << ", " << pos.y(); +} +void ConnectionPixmapItem::mousePressEvent(QGraphicsSceneMouseEvent* event) { + QPointF pos = event->pos(); +} + void ElevationMetatilesPixmapItem::updateCurHoveredMetatile(QPointF pos) { int x = ((int)pos.x()) / 16; int y = ((int)pos.y()) / 16; diff --git a/editor.h b/editor.h index 954da138..0bc6a0cf 100755 --- a/editor.h +++ b/editor.h @@ -13,6 +13,7 @@ class DraggablePixmapItem; class MapPixmapItem; class CollisionPixmapItem; +class ConnectionPixmapItem; class MetatilesPixmapItem; class CollisionMetatilesPixmapItem; class ElevationMetatilesPixmapItem; @@ -44,6 +45,10 @@ public: void setEditingMap(); void setEditingCollision(); void setEditingObjects(); + void setEditingConnections(QString direction); + void showCurrentConnectionMap(QString curDirection); + void setConnectionsVisibility(bool visible); + void updateConnectionOffset(int offset); DraggablePixmapItem *addMapObject(Event *event); void selectMapObject(DraggablePixmapItem *object); @@ -58,6 +63,7 @@ public: QGraphicsScene *scene = NULL; QGraphicsPixmapItem *current_view = NULL; MapPixmapItem *map_item = NULL; + ConnectionPixmapItem *connection_item = NULL; CollisionPixmapItem *collision_item = NULL; QGraphicsItemGroup *objects_group = NULL; @@ -80,10 +86,12 @@ public: private slots: void mouseEvent_map(QGraphicsSceneMouseEvent *event, MapPixmapItem *item); void mouseEvent_collision(QGraphicsSceneMouseEvent *event, CollisionPixmapItem *item); + void onConnectionOffsetChanged(int newOffset); signals: void objectsChanged(); void selectedObjectsChanged(); + void connectionOffsetChanged(int newOffset); }; @@ -240,6 +248,33 @@ protected: void mouseReleaseEvent(QGraphicsSceneMouseEvent*); }; +class ConnectionPixmapItem : public QObject, public QGraphicsPixmapItem { + Q_OBJECT +public: + ConnectionPixmapItem(QPixmap pixmap, Connection* connection, int x, int y): QGraphicsPixmapItem(pixmap) { + this->connection = connection; + setFlag(ItemIsMovable); + setFlag(ItemIsSelectable); + setFlag(ItemSendsGeometryChanges); + this->initialX = x; + this->initialY = y; + this->initialOffset = connection->offset.toInt(); + } + Connection* connection; + int initialX; + int initialY; + int initialOffset; +protected: + QVariant itemChange(GraphicsItemChange change, const QVariant &value); + void dragEnterEvent(QGraphicsSceneDragDropEvent *event) override; + void dragLeaveEvent(QGraphicsSceneDragDropEvent *event) override; + void dropEvent(QGraphicsSceneDragDropEvent *event) override; + void dragMoveEvent(QGraphicsSceneDragDropEvent *event) override; + void mousePressEvent(QGraphicsSceneMouseEvent*); +signals: + void connectionMoved(int offset); +}; + class MetatilesPixmapItem : public QObject, public QGraphicsPixmapItem { Q_OBJECT public: diff --git a/mainwindow.cpp b/mainwindow.cpp index 464d397d..517384ca 100755 --- a/mainwindow.cpp +++ b/mainwindow.cpp @@ -30,6 +30,7 @@ MainWindow::MainWindow(QWidget *parent) : editor->gridToggleCheckbox = ui->checkBox_ToggleGrid; connect(editor, SIGNAL(objectsChanged()), this, SLOT(updateSelectedObjects())); connect(editor, SIGNAL(selectedObjectsChanged()), this, SLOT(updateSelectedObjects())); + connect(editor, SIGNAL(connectionOffsetChanged(int)), this, SLOT(onConnectionOffsetChanged(int))); on_toolButton_Paint_clicked(); @@ -143,15 +144,7 @@ void MainWindow::setMap(QString map_name) { } editor->setMap(map_name); - if (ui->tabWidget->currentIndex() == 1) { - editor->setEditingObjects(); - } else { - if (ui->tabWidget_2->currentIndex() == 1) { - editor->setEditingCollision(); - } else { - editor->setEditingMap(); - } - } + on_tabWidget_currentChanged(ui->tabWidget->currentIndex()); ui->graphicsView_Map->setScene(editor->scene); ui->graphicsView_Map->setSceneRect(editor->scene->sceneRect()); @@ -162,6 +155,8 @@ void MainWindow::setMap(QString map_name) { ui->graphicsView_Objects_Map->setFixedSize(editor->scene->width() + 2, editor->scene->height() + 2); ui->graphicsView_Objects_Map->editor = editor; + ui->graphicsView_Connections->setScene(editor->scene); + ui->graphicsView_Metatiles->setScene(editor->scene_metatiles); //ui->graphicsView_Metatiles->setSceneRect(editor->scene_metatiles->sceneRect()); ui->graphicsView_Metatiles->setFixedSize(editor->metatiles_item->pixmap().width() + 2, editor->metatiles_item->pixmap().height() + 2); @@ -491,6 +486,8 @@ void MainWindow::on_tabWidget_currentChanged(int index) on_tabWidget_2_currentChanged(ui->tabWidget_2->currentIndex()); } else if (index == 1) { editor->setEditingObjects(); + } else if (index == 3) { + editor->setEditingConnections(ui->comboBox_ConnectionDirection->currentText().toLower()); } } @@ -768,3 +765,20 @@ void MainWindow::on_action_Export_Map_Image_triggered() editor->map_item->pixmap().save(filepath); } } + +void MainWindow::on_comboBox_ConnectionDirection_currentIndexChanged(const QString &direction) +{ + editor->showCurrentConnectionMap(direction.toLower()); +} + +void MainWindow::on_spinBox_ConnectionOffset_valueChanged(int offset) +{ + editor->updateConnectionOffset(offset); +} + +void MainWindow::onConnectionOffsetChanged(int offset) +{ + ui->spinBox_ConnectionOffset->blockSignals(true); + ui->spinBox_ConnectionOffset->setValue(offset); + ui->spinBox_ConnectionOffset->blockSignals(false); +} diff --git a/mainwindow.h b/mainwindow.h index e1b443a1..c87a8171 100755 --- a/mainwindow.h +++ b/mainwindow.h @@ -74,6 +74,12 @@ private slots: void on_action_Export_Map_Image_triggered(); + void on_comboBox_ConnectionDirection_currentIndexChanged(const QString &arg1); + + void on_spinBox_ConnectionOffset_valueChanged(int offset); + + void onConnectionOffsetChanged(int offset); + private: Ui::MainWindow *ui; QStandardItemModel *mapListModel; diff --git a/mainwindow.ui b/mainwindow.ui index d1faa64a..9ffce740 100755 --- a/mainwindow.ui +++ b/mainwindow.ui @@ -60,7 +60,7 @@ - 0 + 3 false @@ -1266,7 +1266,7 @@ QFrame::Raised - + 4 @@ -1286,22 +1286,22 @@ - North + Up - East + Right - South + Down - West + Left @@ -1336,6 +1336,20 @@ + + + + Offset + + + + + + + -99 + + + @@ -1377,78 +1391,7 @@ 0 - - - true - - - - - 0 - 0 - 826 - 621 - - - - - - - - - - Qt::Vertical - - - - 20 - 40 - - - - - - - - Qt::Vertical - - - - 20 - 40 - - - - - - - - Qt::Horizontal - - - - 40 - 20 - - - - - - - - Qt::Horizontal - - - - 40 - 20 - - - - - - - + diff --git a/map.h b/map.h index b05a60ea..12b62c01 100755 --- a/map.h +++ b/map.h @@ -8,6 +8,7 @@ #include #include #include +#include template @@ -179,6 +180,7 @@ public: QMap> events; QList connections; + QMap connection_items; QPixmap renderConnection(Connection); QImage border_image; diff --git a/project.cpp b/project.cpp index fd54f6a9..068bd554 100755 --- a/project.cpp +++ b/project.cpp @@ -67,6 +67,7 @@ void Project::loadMapConnections(Map *map) { } map->connections.clear(); + map->connection_items.clear(); if (!map->connections_label.isNull()) { QString path = root + QString("/data/maps/%1/connections.inc").arg(map->name); QString text = readTextFile(path); From 073a13ac9ca67cce4c4559a788ba2651be6ad1da Mon Sep 17 00:00:00 2001 From: Marcus Huderle Date: Wed, 7 Mar 2018 21:05:35 -0800 Subject: [PATCH 03/20] Save connections to file --- project.cpp | 25 +++++++++++++++++++++++++ project.h | 1 + 2 files changed, 26 insertions(+) diff --git a/project.cpp b/project.cpp index 068bd554..9053b164 100755 --- a/project.cpp +++ b/project.cpp @@ -210,6 +210,30 @@ void Project::saveMapHeader(Map *map) { saveTextFile(header_path, text); } +void Project::saveMapConnections(Map *map) { + QString connections_path = root + "/data/maps/" + map->name + "/connections.inc"; + QString connectionsListLabel = QString("%1_MapConnectionsList").arg(map->name); + int numValidConnections = 0; + QString text = ""; + text += QString("%1::\n").arg(connectionsListLabel); + for (Connection* connection : map->connections) { + if (mapNamesToMapConstants->contains(connection->map_name)) { + text += QString("\tconnection %1, %2, %3\n") + .arg(connection->direction) + .arg(connection->offset) + .arg(mapNamesToMapConstants->value(connection->map_name)); + numValidConnections++; + } else { + qDebug() << QString("Failed to write map connection. %1 not a valid map name").arg(connection->map_name); + } + } + text += QString("\n"); + text += QString("%1::\n").arg(map->connections_label); + text += QString("\t.4byte %1\n").arg(numValidConnections); + text += QString("\t.4byte %1\n").arg(connectionsListLabel); + saveTextFile(connections_path, text); +} + void Project::readMapAttributesTable() { int curMapIndex = 1; QString attributesText = readTextFile(getMapAttributesTableFilepath()); @@ -680,6 +704,7 @@ void Project::saveMap(Map *map) { saveMapBorder(map); saveMapHeader(map); + saveMapConnections(map); saveBlockdata(map); saveMapEvents(map); diff --git a/project.h b/project.h index 43736c2a..0c064444 100755 --- a/project.h +++ b/project.h @@ -97,6 +97,7 @@ private: QString getMapAttributesTableFilepath(); QString getMapAssetsFilepath(); void saveMapHeader(Map*); + void saveMapConnections(Map*); void saveMapAttributesTable(); void updateMapAttributes(Map* map); void readCDefinesSorted(QString, QStringList, QStringList*); From c00d83da4612fe39d3979a064f75502bfe9a156e Mon Sep 17 00:00:00 2001 From: Marcus Huderle Date: Thu, 8 Mar 2018 20:34:04 -0800 Subject: [PATCH 04/20] Support changing connection maps, adding new connections, and removing connections --- editor.cpp | 77 +++++++++++++++++++++++++++++++++++++++++------- editor.h | 8 ++--- graphicsview.cpp | 1 + graphicsview.h | 4 +-- mainwindow.cpp | 10 ++----- mainwindow.h | 2 +- 6 files changed, 78 insertions(+), 24 deletions(-) diff --git a/editor.cpp b/editor.cpp index 675a3811..cdeb6654 100755 --- a/editor.cpp +++ b/editor.cpp @@ -3,8 +3,9 @@ #include #include -Editor::Editor() +Editor::Editor(Ui::MainWindow* ui) { + this->ui = ui; selected_events = new QList; } @@ -85,6 +86,10 @@ void Editor::setEditingConnections(QString direction) { map_item->draw(); map_item->setVisible(true); map_item->setEnabled(true); + ui->comboBox_ConnectedMap->blockSignals(true); + ui->comboBox_ConnectedMap->clear(); + ui->comboBox_ConnectedMap->addItems(*project->mapNames); + ui->comboBox_ConnectedMap->blockSignals(false); setConnectionsVisibility(false); showCurrentConnectionMap(direction); } @@ -124,6 +129,11 @@ void Editor::showCurrentConnectionMap(QString curDirection) { x = map->getWidth() * 16; y = offset * 16; } + + QPainter painter(&pixmap); + painter.setPen(QColor(255, 0, 255)); + painter.drawRect(0, 0, pixmap.width() - 1, pixmap.height() - 1); + painter.end(); connection_item = new ConnectionPixmapItem(pixmap, connection, x, y); connection_item->setX(x); connection_item->setY(y); @@ -133,18 +143,30 @@ void Editor::showCurrentConnectionMap(QString curDirection) { connect(connection_item, SIGNAL(connectionMoved(int)), this, SLOT(onConnectionOffsetChanged(int))); onConnectionOffsetChanged(connection->offset.toInt()); + + ui->comboBox_ConnectedMap->setCurrentText(connection->map_name); break; } - if (!connectionExists && connection_item) { - scene->removeItem(connection_item); - delete connection_item; - connection_item = NULL; + if (!connectionExists) { + if (connection_item) { + scene->removeItem(connection_item); + delete connection_item; + connection_item = NULL; + } + + ui->comboBox_ConnectedMap->setCurrentText(""); + ui->spinBox_ConnectionOffset->setDisabled(true); + ui->spinBox_ConnectionOffset->setValue(0); + } else { + ui->spinBox_ConnectionOffset->setDisabled(false); } } void Editor::onConnectionOffsetChanged(int newOffset) { - emit connectionOffsetChanged(newOffset); + ui->spinBox_ConnectionOffset->blockSignals(true); + ui->spinBox_ConnectionOffset->setValue(newOffset); + ui->spinBox_ConnectionOffset->blockSignals(false); } void Editor::setConnectionsVisibility(bool visible) { @@ -330,18 +352,21 @@ void Editor::displayMapGrid() { for (int i = 0; i <= map->getWidth(); i++) { int x = i * 16; QGraphicsLineItem *line = scene->addLine(x, 0, x, pixelHeight); - line->setVisible(gridToggleCheckbox->isChecked()); - connect(gridToggleCheckbox, &QCheckBox::toggled, [=](bool checked){line->setVisible(checked);}); + line->setVisible(ui->checkBox_ToggleGrid->isChecked()); + connect(ui->checkBox_ToggleGrid, &QCheckBox::toggled, [=](bool checked){line->setVisible(checked);}); } for (int j = 0; j <= map->getHeight(); j++) { int y = j * 16; QGraphicsLineItem *line = scene->addLine(0, y, pixelWidth, y); - line->setVisible(gridToggleCheckbox->isChecked()); - connect(gridToggleCheckbox, &QCheckBox::toggled, [=](bool checked){line->setVisible(checked);}); + line->setVisible(ui->checkBox_ToggleGrid->isChecked()); + connect(ui->checkBox_ToggleGrid, &QCheckBox::toggled, [=](bool checked){line->setVisible(checked);}); } } void Editor::updateConnectionOffset(int offset) { + if (!connection_item) + return; + connection_item->blockSignals(true); connection_item->connection->offset = QString::number(offset); if (connection_item->connection->direction == "up" || connection_item->connection->direction == "down") { @@ -352,6 +377,38 @@ void Editor::updateConnectionOffset(int offset) { connection_item->blockSignals(false); } +void Editor::updateConnectionMap(QString mapName, QString direction) { + if (!mapName.isEmpty() && !project->mapNames->contains(mapName)) { + qDebug() << "Invalid map name " << mapName << " specified for connection."; + return; + } + + if (connection_item) { + // Find the connection we are updating. + bool foundConnection = false; + for (Connection* connection : map->connections) { + if (connection->direction == direction) { + foundConnection = true; + if (mapName.isEmpty()) { + map->connections.removeOne(connection); + } else { + connection->map_name = mapName; + } + break; + } + } + } else if (!mapName.isEmpty()) { + // Create a brand new connection. + Connection* newConnection = new Connection; + newConnection->direction = direction; + newConnection->offset = "0"; + newConnection->map_name = mapName; + map->connections.append(newConnection); + } + + showCurrentConnectionMap(direction); +} + void MetatilesPixmapItem::paintTileChanged(Map *map) { draw(); } diff --git a/editor.h b/editor.h index 0bc6a0cf..deed33db 100755 --- a/editor.h +++ b/editor.h @@ -9,6 +9,7 @@ #include #include "project.h" +#include "ui_mainwindow.h" class DraggablePixmapItem; class MapPixmapItem; @@ -22,12 +23,12 @@ class Editor : public QObject { Q_OBJECT public: - Editor(); + Editor(Ui::MainWindow* ui); public: + Ui::MainWindow* ui; QObject *parent = NULL; Project *project = NULL; Map *map = NULL; - QCheckBox *gridToggleCheckbox = NULL; void saveProject(); void save(); void undo(); @@ -49,6 +50,7 @@ public: void showCurrentConnectionMap(QString curDirection); void setConnectionsVisibility(bool visible); void updateConnectionOffset(int offset); + void updateConnectionMap(QString mapName, QString direction); DraggablePixmapItem *addMapObject(Event *event); void selectMapObject(DraggablePixmapItem *object); @@ -91,7 +93,6 @@ private slots: signals: void objectsChanged(); void selectedObjectsChanged(); - void connectionOffsetChanged(int newOffset); }; @@ -254,7 +255,6 @@ public: ConnectionPixmapItem(QPixmap pixmap, Connection* connection, int x, int y): QGraphicsPixmapItem(pixmap) { this->connection = connection; setFlag(ItemIsMovable); - setFlag(ItemIsSelectable); setFlag(ItemSendsGeometryChanges); this->initialX = x; this->initialY = y; diff --git a/graphicsview.cpp b/graphicsview.cpp index 3e11cee9..361ec3a9 100755 --- a/graphicsview.cpp +++ b/graphicsview.cpp @@ -1,4 +1,5 @@ #include "graphicsview.h" +#include "editor.h" void GraphicsView::mousePressEvent(QMouseEvent *event) { QGraphicsView::mousePressEvent(event); diff --git a/graphicsview.h b/graphicsview.h index 0734715e..1d0711fc 100755 --- a/graphicsview.h +++ b/graphicsview.h @@ -4,7 +4,7 @@ #include #include -#include "editor.h" +class Editor; /* class GraphicsView_Object : public QObject @@ -26,7 +26,7 @@ public: public: // GraphicsView_Object object; - Editor *editor = NULL; + Editor *editor; protected: void mousePressEvent(QMouseEvent *event); void mouseMoveEvent(QMouseEvent *event); diff --git a/mainwindow.cpp b/mainwindow.cpp index 517384ca..0ac38cba 100755 --- a/mainwindow.cpp +++ b/mainwindow.cpp @@ -26,11 +26,9 @@ MainWindow::MainWindow(QWidget *parent) : ui->setupUi(this); new QShortcut(QKeySequence(Qt::CTRL + Qt::SHIFT + Qt::Key_Z), this, SLOT(redo())); - editor = new Editor; - editor->gridToggleCheckbox = ui->checkBox_ToggleGrid; + editor = new Editor(ui); connect(editor, SIGNAL(objectsChanged()), this, SLOT(updateSelectedObjects())); connect(editor, SIGNAL(selectedObjectsChanged()), this, SLOT(updateSelectedObjects())); - connect(editor, SIGNAL(connectionOffsetChanged(int)), this, SLOT(onConnectionOffsetChanged(int))); on_toolButton_Paint_clicked(); @@ -776,9 +774,7 @@ void MainWindow::on_spinBox_ConnectionOffset_valueChanged(int offset) editor->updateConnectionOffset(offset); } -void MainWindow::onConnectionOffsetChanged(int offset) +void MainWindow::on_comboBox_ConnectedMap_currentTextChanged(const QString &mapName) { - ui->spinBox_ConnectionOffset->blockSignals(true); - ui->spinBox_ConnectionOffset->setValue(offset); - ui->spinBox_ConnectionOffset->blockSignals(false); + editor->updateConnectionMap(mapName, ui->comboBox_ConnectionDirection->currentText().toLower()); } diff --git a/mainwindow.h b/mainwindow.h index c87a8171..fd72b873 100755 --- a/mainwindow.h +++ b/mainwindow.h @@ -78,7 +78,7 @@ private slots: void on_spinBox_ConnectionOffset_valueChanged(int offset); - void onConnectionOffsetChanged(int offset); + void on_comboBox_ConnectedMap_currentTextChanged(const QString &mapName); private: Ui::MainWindow *ui; From 1e8d1d9497a2d8a1e98199aba6e5797c601014b9 Mon Sep 17 00:00:00 2001 From: Marcus Huderle Date: Thu, 8 Mar 2018 21:18:00 -0800 Subject: [PATCH 05/20] Hide connection editor when switching tabs --- editor.cpp | 20 +++++++++++++++++++- 1 file changed, 19 insertions(+), 1 deletion(-) diff --git a/editor.cpp b/editor.cpp index cdeb6654..319c9a4c 100755 --- a/editor.cpp +++ b/editor.cpp @@ -38,6 +38,7 @@ void Editor::redo() { void Editor::setEditingMap() { current_view = map_item; if (map_item) { + displayMapConnections(); map_item->draw(); map_item->setVisible(true); map_item->setEnabled(true); @@ -49,6 +50,10 @@ void Editor::setEditingMap() { if (objects_group) { objects_group->setVisible(false); } + if (connection_item) { + connection_item->setVisible(false); + connection_item->setEnabled(false); + } } void Editor::setEditingCollision() { @@ -63,6 +68,10 @@ void Editor::setEditingCollision() { if (objects_group) { objects_group->setVisible(false); } + if (connection_item) { + connection_item->setVisible(false); + connection_item->setEnabled(false); + } } void Editor::setEditingObjects() { @@ -78,6 +87,10 @@ void Editor::setEditingObjects() { if (collision_item) { collision_item->setVisible(false); } + if (connection_item) { + connection_item->setVisible(false); + connection_item->setEnabled(false); + } } void Editor::setEditingConnections(QString direction) { @@ -85,7 +98,7 @@ void Editor::setEditingConnections(QString direction) { if (map_item) { map_item->draw(); map_item->setVisible(true); - map_item->setEnabled(true); + map_item->setEnabled(false); ui->comboBox_ConnectedMap->blockSignals(true); ui->comboBox_ConnectedMap->clear(); ui->comboBox_ConnectedMap->addItems(*project->mapNames); @@ -304,6 +317,11 @@ DraggablePixmapItem *Editor::addMapObject(Event *event) { } void Editor::displayMapConnections() { + for (QString key : map->connection_items.keys()) { + scene->removeItem(map->connection_items.value(key)); + delete map->connection_items.value(key); + } + for (Connection *connection : map->connections) { if (connection->direction == "dive" || connection->direction == "emerge") { continue; From c553980105862c93537b671476163122b08640e1 Mon Sep 17 00:00:00 2001 From: Marcus Huderle Date: Thu, 8 Mar 2018 21:26:40 -0800 Subject: [PATCH 06/20] Properly remove connections --- editor.cpp | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/editor.cpp b/editor.cpp index 319c9a4c..eb67f471 100755 --- a/editor.cpp +++ b/editor.cpp @@ -166,6 +166,11 @@ void Editor::showCurrentConnectionMap(QString curDirection) { scene->removeItem(connection_item); delete connection_item; connection_item = NULL; + + if (map->connection_items.contains(curDirection)) { + delete map->connection_items.value(curDirection); + map->connection_items.remove(curDirection); + } } ui->comboBox_ConnectedMap->setCurrentText(""); From 2b5da0ee01b469d3aae48db01c6576bbb255107b Mon Sep 17 00:00:00 2001 From: Marcus Huderle Date: Thu, 8 Mar 2018 22:34:51 -0800 Subject: [PATCH 07/20] Use same graphicswindow format as Map tab --- mainwindow.ui | 81 +++++++++++++++++++++++++++++++++++++++++++++++++-- 1 file changed, 79 insertions(+), 2 deletions(-) diff --git a/mainwindow.ui b/mainwindow.ui index 9ffce740..131449fb 100755 --- a/mainwindow.ui +++ b/mainwindow.ui @@ -60,7 +60,7 @@ - 3 + 0 false @@ -1391,7 +1391,84 @@ 0 - + + + + 1 + 0 + + + + true + + + + + 0 + 0 + 826 + 621 + + + + + + + + + + Qt::Horizontal + + + + 40 + 20 + + + + + + + + Qt::Horizontal + + + + 40 + 20 + + + + + + + + Qt::Vertical + + + + 20 + 40 + + + + + + + + Qt::Vertical + + + + 20 + 40 + + + + + + + From 8df2a864a0504a89bbc7f6ebf92e05215babadcb Mon Sep 17 00:00:00 2001 From: Marcus Huderle Date: Thu, 8 Mar 2018 22:35:16 -0800 Subject: [PATCH 08/20] Fixup connection graphicswindow dimensions --- editor.cpp | 2 -- mainwindow.cpp | 2 ++ 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/editor.cpp b/editor.cpp index eb67f471..75b665b1 100755 --- a/editor.cpp +++ b/editor.cpp @@ -152,7 +152,6 @@ void Editor::showCurrentConnectionMap(QString curDirection) { connection_item->setY(y); connection_item->setZValue(21); scene->addItem(connection_item); - scene->setSceneRect(0, 0, pixmap.width() + map_item->pixmap().width(), pixmap.height() + map_item->pixmap().height()); connect(connection_item, SIGNAL(connectionMoved(int)), this, SLOT(onConnectionOffsetChanged(int))); onConnectionOffsetChanged(connection->offset.toInt()); @@ -163,7 +162,6 @@ void Editor::showCurrentConnectionMap(QString curDirection) { if (!connectionExists) { if (connection_item) { - scene->removeItem(connection_item); delete connection_item; connection_item = NULL; diff --git a/mainwindow.cpp b/mainwindow.cpp index 0ac38cba..0cc057af 100755 --- a/mainwindow.cpp +++ b/mainwindow.cpp @@ -154,6 +154,8 @@ void MainWindow::setMap(QString map_name) { ui->graphicsView_Objects_Map->editor = editor; ui->graphicsView_Connections->setScene(editor->scene); + ui->graphicsView_Connections->setSceneRect(editor->scene->sceneRect()); + ui->graphicsView_Connections->setFixedSize(editor->scene->width() + 2, editor->scene->height() + 2); ui->graphicsView_Metatiles->setScene(editor->scene_metatiles); //ui->graphicsView_Metatiles->setSceneRect(editor->scene_metatiles->sceneRect()); From 9a6132314c17e0242bed65cb1bf18eb3ed7721f6 Mon Sep 17 00:00:00 2001 From: Marcus Huderle Date: Fri, 9 Mar 2018 23:26:44 -0800 Subject: [PATCH 09/20] Support multiple connections in same direction, and darken non-selected connections --- editor.cpp | 281 +++++++++++++++++++++++++++---------------------- editor.h | 33 ++++-- mainwindow.cpp | 4 +- mainwindow.ui | 25 +++-- map.h | 2 +- 5 files changed, 204 insertions(+), 141 deletions(-) diff --git a/editor.cpp b/editor.cpp index 75b665b1..d4dcf0a0 100755 --- a/editor.cpp +++ b/editor.cpp @@ -50,10 +50,8 @@ void Editor::setEditingMap() { if (objects_group) { objects_group->setVisible(false); } - if (connection_item) { - connection_item->setVisible(false); - connection_item->setEnabled(false); - } + setBorderItemsVisible(true); + setConnectionItemsVisible(false); } void Editor::setEditingCollision() { @@ -68,10 +66,8 @@ void Editor::setEditingCollision() { if (objects_group) { objects_group->setVisible(false); } - if (connection_item) { - connection_item->setVisible(false); - connection_item->setEnabled(false); - } + setBorderItemsVisible(true); + setConnectionItemsVisible(false); } void Editor::setEditingObjects() { @@ -87,13 +83,11 @@ void Editor::setEditingObjects() { if (collision_item) { collision_item->setVisible(false); } - if (connection_item) { - connection_item->setVisible(false); - connection_item->setEnabled(false); - } + setBorderItemsVisible(true); + setConnectionItemsVisible(false); } -void Editor::setEditingConnections(QString direction) { +void Editor::setEditingConnections() { current_view = map_item; if (map_item) { map_item->draw(); @@ -104,7 +98,10 @@ void Editor::setEditingConnections(QString direction) { ui->comboBox_ConnectedMap->addItems(*project->mapNames); ui->comboBox_ConnectedMap->blockSignals(false); setConnectionsVisibility(false); - showCurrentConnectionMap(direction); + if (current_connection_edit_item) { + onConnectionOffsetChanged(current_connection_edit_item->connection->offset.toInt()); + updateConnectionMap(current_connection_edit_item->connection->map_name, current_connection_edit_item->connection->direction); + } } if (collision_item) { collision_item->setVisible(false); @@ -112,71 +109,63 @@ void Editor::setEditingConnections(QString direction) { if (objects_group) { objects_group->setVisible(false); } + setBorderItemsVisible(true, 0.4); + setConnectionItemsVisible(true); } -void Editor::showCurrentConnectionMap(QString curDirection) { - bool connectionExists = false; - for (Connection* connection : map->connections) { - if (connection->direction != curDirection) continue; - if (connection_item) { - scene->removeItem(connection_item); - delete connection_item; - connection_item = NULL; - } +void Editor::setConnectionItemsVisible(bool visible) { + for (ConnectionPixmapItem* item : connection_edit_items) { + item->setVisible(visible); + item->setEnabled(visible); + } +} - connectionExists = true; - Map *connected_map = project->getMap(connection->map_name); - QPixmap pixmap = connected_map->renderConnection(*connection); - int offset = connection->offset.toInt(nullptr, 0); - int x = 0, y = 0; - if (connection->direction == "up") { - x = offset * 16; - y = -pixmap.height(); - } else if (connection->direction == "down") { - x = offset * 16; - y = map->getHeight() * 16; - } else if (connection->direction == "left") { - x = -pixmap.width(); - y = offset * 16; - } else if (connection->direction == "right") { - x = map->getWidth() * 16; - y = offset * 16; - } +void Editor::setBorderItemsVisible(bool visible, qreal opacity) { + for (QGraphicsPixmapItem* item : borderItems) { + item->setVisible(visible); + item->setOpacity(opacity); + } +} - QPainter painter(&pixmap); - painter.setPen(QColor(255, 0, 255)); - painter.drawRect(0, 0, pixmap.width() - 1, pixmap.height() - 1); - painter.end(); - connection_item = new ConnectionPixmapItem(pixmap, connection, x, y); - connection_item->setX(x); - connection_item->setY(y); - connection_item->setZValue(21); - scene->addItem(connection_item); +void Editor::setCurrentConnectionDirection(QString curDirection) { + if (!current_connection_edit_item) + return; - connect(connection_item, SIGNAL(connectionMoved(int)), this, SLOT(onConnectionOffsetChanged(int))); - onConnectionOffsetChanged(connection->offset.toInt()); - - ui->comboBox_ConnectedMap->setCurrentText(connection->map_name); - break; + current_connection_edit_item->connection->direction = curDirection; + Map *connected_map = project->getMap(current_connection_edit_item->connection->map_name); + QPixmap pixmap = connected_map->renderConnection(*current_connection_edit_item->connection); + int offset = current_connection_edit_item->connection->offset.toInt(nullptr, 0); + current_connection_edit_item->initialOffset = offset; + int x = 0, y = 0; + if (current_connection_edit_item->connection->direction == "up") { + x = offset * 16; + y = -pixmap.height(); + } else if (current_connection_edit_item->connection->direction == "down") { + x = offset * 16; + y = map->getHeight() * 16; + } else if (current_connection_edit_item->connection->direction == "left") { + x = -pixmap.width(); + y = offset * 16; + } else if (current_connection_edit_item->connection->direction == "right") { + x = map->getWidth() * 16; + y = offset * 16; } - if (!connectionExists) { - if (connection_item) { - delete connection_item; - connection_item = NULL; + current_connection_edit_item->basePixmap = pixmap; + QPainter painter(&pixmap); + painter.setPen(QColor(255, 0, 255)); + painter.drawRect(0, 0, pixmap.width() - 1, pixmap.height() - 1); + painter.end(); + current_connection_edit_item->setPixmap(pixmap); + current_connection_edit_item->initialX = x; + current_connection_edit_item->initialY = y; + current_connection_edit_item->blockSignals(true); + current_connection_edit_item->setX(x); + current_connection_edit_item->setY(y); + current_connection_edit_item->setZValue(-1); + current_connection_edit_item->blockSignals(false); - if (map->connection_items.contains(curDirection)) { - delete map->connection_items.value(curDirection); - map->connection_items.remove(curDirection); - } - } - - ui->comboBox_ConnectedMap->setCurrentText(""); - ui->spinBox_ConnectionOffset->setDisabled(true); - ui->spinBox_ConnectionOffset->setValue(0); - } else { - ui->spinBox_ConnectionOffset->setDisabled(false); - } + setConnectionEditControlValues(current_connection_edit_item->connection); } void Editor::onConnectionOffsetChanged(int newOffset) { @@ -185,6 +174,54 @@ void Editor::onConnectionOffsetChanged(int newOffset) { ui->spinBox_ConnectionOffset->blockSignals(false); } +void Editor::setConnectionEditControlValues(Connection* connection) { + ui->comboBox_ConnectedMap->blockSignals(true); + ui->comboBox_ConnectionDirection->blockSignals(true); + ui->spinBox_ConnectionOffset->blockSignals(true); + + ui->comboBox_ConnectedMap->setCurrentText(connection->map_name); + ui->comboBox_ConnectionDirection->setCurrentText(connection->direction); + ui->spinBox_ConnectionOffset->setValue(connection->offset.toInt()); + + ui->comboBox_ConnectedMap->blockSignals(false); + ui->comboBox_ConnectionDirection->blockSignals(false); + ui->spinBox_ConnectionOffset->blockSignals(false); +} + +void Editor::setConnectionEditControlsEnabled(bool enabled) { + ui->comboBox_ConnectionDirection->setEnabled(enabled); + ui->comboBox_ConnectedMap->setEnabled(enabled); + ui->spinBox_ConnectionOffset->setEnabled(enabled); +} + +void Editor::onConnectionItemSelected(ConnectionPixmapItem* connectionItem) { + for (ConnectionPixmapItem* item : connection_edit_items) { + bool isSelectedItem = item == connectionItem; + int zValue = isSelectedItem ? 0 : -1; + qreal opacity = isSelectedItem ? 1 : 0.75; + item->setZValue(zValue); + item->render(opacity); + if (isSelectedItem) { + QPixmap pixmap = item->pixmap(); + QPainter painter(&pixmap); + painter.setPen(QColor(255, 0, 255)); + painter.drawRect(0, 0, pixmap.width() - 1, pixmap.height() - 1); + painter.end(); + item->setPixmap(pixmap); + } + } + current_connection_edit_item = connectionItem; + current_connection_edit_item->setZValue(0); + setConnectionEditControlsEnabled(true); + setConnectionEditControlValues(current_connection_edit_item->connection); +} + +void Editor::onConnectionDirectionChanged(QString newDirection) { + ui->comboBox_ConnectionDirection->blockSignals(true); + ui->comboBox_ConnectionDirection->setCurrentText(newDirection); + ui->comboBox_ConnectionDirection->blockSignals(false); +} + void Editor::setConnectionsVisibility(bool visible) { for (QGraphicsPixmapItem* item : map->connection_items) { item->setVisible(visible); @@ -320,10 +357,16 @@ DraggablePixmapItem *Editor::addMapObject(Event *event) { } void Editor::displayMapConnections() { - for (QString key : map->connection_items.keys()) { - scene->removeItem(map->connection_items.value(key)); - delete map->connection_items.value(key); + for (QGraphicsPixmapItem* item : map->connection_items) { + scene->removeItem(item); + delete item; } + map->connection_items.clear(); + + for (ConnectionPixmapItem* item : connection_edit_items) { + delete item; + } + connection_edit_items.clear(); for (Connection *connection : map->connections) { if (connection->direction == "dive" || connection->direction == "emerge") { @@ -346,12 +389,26 @@ void Editor::displayMapConnections() { x = map->getWidth() * 16; y = offset * 16; } + QGraphicsPixmapItem *item = new QGraphicsPixmapItem(pixmap); item->setZValue(-1); item->setX(x); item->setY(y); scene->addItem(item); - map->connection_items.insert(connection->direction, item); + map->connection_items.append(item); + + ConnectionPixmapItem *connection_edit_item = new ConnectionPixmapItem(pixmap, connection, x, y); + connection_edit_item->setX(x); + connection_edit_item->setY(y); + connection_edit_item->setZValue(-1); + scene->addItem(connection_edit_item); + connect(connection_edit_item, SIGNAL(connectionMoved(int)), this, SLOT(onConnectionOffsetChanged(int))); + connect(connection_edit_item, SIGNAL(connectionItemSelected(ConnectionPixmapItem*)), this, SLOT(onConnectionItemSelected(ConnectionPixmapItem*))); + connection_edit_items.append(connection_edit_item); + } + + if (!connection_edit_items.empty()) { + onConnectionItemSelected(connection_edit_items.first()); } } @@ -364,6 +421,7 @@ void Editor::displayMapBorder() { item->setY(y * 16); item->setZValue(-2); scene->addItem(item); + borderItems.append(item); } } @@ -385,17 +443,17 @@ void Editor::displayMapGrid() { } void Editor::updateConnectionOffset(int offset) { - if (!connection_item) + if (!current_connection_edit_item) return; - connection_item->blockSignals(true); - connection_item->connection->offset = QString::number(offset); - if (connection_item->connection->direction == "up" || connection_item->connection->direction == "down") { - connection_item->setX(connection_item->initialX + (offset - connection_item->initialOffset) * 16); + current_connection_edit_item->blockSignals(true); + current_connection_edit_item->connection->offset = QString::number(offset); + if (current_connection_edit_item->connection->direction == "up" || current_connection_edit_item->connection->direction == "down") { + current_connection_edit_item->setX(current_connection_edit_item->initialX + (offset - current_connection_edit_item->initialOffset) * 16); } else { - connection_item->setY(connection_item->initialY + (offset - connection_item->initialOffset) * 16); + current_connection_edit_item->setY(current_connection_edit_item->initialY + (offset - current_connection_edit_item->initialOffset) * 16); } - connection_item->blockSignals(false); + current_connection_edit_item->blockSignals(false); } void Editor::updateConnectionMap(QString mapName, QString direction) { @@ -403,31 +461,24 @@ void Editor::updateConnectionMap(QString mapName, QString direction) { qDebug() << "Invalid map name " << mapName << " specified for connection."; return; } + if (!current_connection_edit_item) + return; - if (connection_item) { - // Find the connection we are updating. - bool foundConnection = false; - for (Connection* connection : map->connections) { - if (connection->direction == direction) { - foundConnection = true; - if (mapName.isEmpty()) { - map->connections.removeOne(connection); - } else { - connection->map_name = mapName; - } - break; - } - } - } else if (!mapName.isEmpty()) { - // Create a brand new connection. - Connection* newConnection = new Connection; - newConnection->direction = direction; - newConnection->offset = "0"; - newConnection->map_name = mapName; - map->connections.append(newConnection); + if (mapName.isEmpty()) { + map->connections.removeOne(current_connection_edit_item->connection); + connection_edit_items.removeOne(current_connection_edit_item); + scene->removeItem(current_connection_edit_item); + delete current_connection_edit_item; + current_connection_edit_item = NULL; + setConnectionEditControlsEnabled(false); + ui->spinBox_ConnectionOffset->setValue(0); + return; + } else { + setConnectionEditControlsEnabled(true); } - showCurrentConnectionMap(direction); + current_connection_edit_item->connection->map_name = mapName; + setCurrentConnectionDirection(direction); } void MetatilesPixmapItem::paintTileChanged(Map *map) { @@ -543,24 +594,8 @@ QVariant ConnectionPixmapItem::itemChange(GraphicsItemChange change, const QVari return QGraphicsItem::itemChange(change, value); } } -void ConnectionPixmapItem::dragEnterEvent(QGraphicsSceneDragDropEvent *event) { - QPointF pos = event->pos(); - qDebug() << "enter: " << pos.x() << ", " << pos.y(); -} -void ConnectionPixmapItem::dragMoveEvent(QGraphicsSceneDragDropEvent *event) { - QPointF pos = event->pos(); - qDebug() << "drag: " << pos.x() << ", " << pos.y(); -} -void ConnectionPixmapItem::dragLeaveEvent(QGraphicsSceneDragDropEvent *event) { - QPointF pos = event->pos(); - qDebug() << "leave: " << pos.x() << ", " << pos.y(); -} -void ConnectionPixmapItem::dropEvent(QGraphicsSceneDragDropEvent *event) { - QPointF pos = event->pos(); - qDebug() << "drop: " << pos.x() << ", " << pos.y(); -} void ConnectionPixmapItem::mousePressEvent(QGraphicsSceneMouseEvent* event) { - QPointF pos = event->pos(); + emit connectionItemSelected(this); } void ElevationMetatilesPixmapItem::updateCurHoveredMetatile(QPointF pos) { @@ -694,10 +729,6 @@ void MapPixmapItem::paintSmartPath(int x, int y) { if (left && IS_SMART_PATH_TILE(left)) id += 8; - if (block) { - qDebug() << "tile: " << block->tile << "base: " << map->paint_tile << "id: " << id; - } - block->tile = map->paint_tile + smartPathTable[id];; map->_setBlock(actualX, actualY, *block); } diff --git a/editor.h b/editor.h index deed33db..60a91d64 100755 --- a/editor.h +++ b/editor.h @@ -46,8 +46,8 @@ public: void setEditingMap(); void setEditingCollision(); void setEditingObjects(); - void setEditingConnections(QString direction); - void showCurrentConnectionMap(QString curDirection); + void setEditingConnections(); + void setCurrentConnectionDirection(QString curDirection); void setConnectionsVisibility(bool visible); void updateConnectionOffset(int offset); void updateConnectionMap(QString mapName, QString direction); @@ -65,9 +65,11 @@ public: QGraphicsScene *scene = NULL; QGraphicsPixmapItem *current_view = NULL; MapPixmapItem *map_item = NULL; - ConnectionPixmapItem *connection_item = NULL; + ConnectionPixmapItem* current_connection_edit_item = NULL; + QList connection_edit_items; CollisionPixmapItem *collision_item = NULL; QGraphicsItemGroup *objects_group = NULL; + QList borderItems; QGraphicsScene *scene_metatiles = NULL; QGraphicsScene *scene_collision_metatiles = NULL; @@ -85,10 +87,18 @@ public: void objectsView_onMouseMove(QMouseEvent *event); void objectsView_onMouseRelease(QMouseEvent *event); +private: + void setConnectionItemsVisible(bool); + void setBorderItemsVisible(bool, qreal = 1); + void setConnectionEditControlValues(Connection*); + void setConnectionEditControlsEnabled(bool); + private slots: void mouseEvent_map(QGraphicsSceneMouseEvent *event, MapPixmapItem *item); void mouseEvent_collision(QGraphicsSceneMouseEvent *event, CollisionPixmapItem *item); void onConnectionOffsetChanged(int newOffset); + void onConnectionItemSelected(ConnectionPixmapItem* connectionItem); + void onConnectionDirectionChanged(QString newDirection); signals: void objectsChanged(); @@ -253,6 +263,7 @@ class ConnectionPixmapItem : public QObject, public QGraphicsPixmapItem { Q_OBJECT public: ConnectionPixmapItem(QPixmap pixmap, Connection* connection, int x, int y): QGraphicsPixmapItem(pixmap) { + this->basePixmap = pixmap; this->connection = connection; setFlag(ItemIsMovable); setFlag(ItemSendsGeometryChanges); @@ -260,18 +271,26 @@ public: this->initialY = y; this->initialOffset = connection->offset.toInt(); } + void render(qreal opacity = 1) { + QPixmap newPixmap = basePixmap.copy(0, 0, basePixmap.width(), basePixmap.height()); + if (opacity < 1) { + QPainter painter(&newPixmap); + int alpha = (int)(255 * (1 - opacity)); + painter.fillRect(0, 0, newPixmap.width(), newPixmap.height(), QColor(0, 0, 0, alpha)); + painter.end(); + } + this->setPixmap(newPixmap); + } + QPixmap basePixmap; Connection* connection; int initialX; int initialY; int initialOffset; protected: QVariant itemChange(GraphicsItemChange change, const QVariant &value); - void dragEnterEvent(QGraphicsSceneDragDropEvent *event) override; - void dragLeaveEvent(QGraphicsSceneDragDropEvent *event) override; - void dropEvent(QGraphicsSceneDragDropEvent *event) override; - void dragMoveEvent(QGraphicsSceneDragDropEvent *event) override; void mousePressEvent(QGraphicsSceneMouseEvent*); signals: + void connectionItemSelected(ConnectionPixmapItem* connectionItem); void connectionMoved(int offset); }; diff --git a/mainwindow.cpp b/mainwindow.cpp index 0cc057af..7ebc21d8 100755 --- a/mainwindow.cpp +++ b/mainwindow.cpp @@ -487,7 +487,7 @@ void MainWindow::on_tabWidget_currentChanged(int index) } else if (index == 1) { editor->setEditingObjects(); } else if (index == 3) { - editor->setEditingConnections(ui->comboBox_ConnectionDirection->currentText().toLower()); + editor->setEditingConnections(); } } @@ -768,7 +768,7 @@ void MainWindow::on_action_Export_Map_Image_triggered() void MainWindow::on_comboBox_ConnectionDirection_currentIndexChanged(const QString &direction) { - editor->showCurrentConnectionMap(direction.toLower()); + editor->setCurrentConnectionDirection(direction); } void MainWindow::on_spinBox_ConnectionOffset_valueChanged(int offset) diff --git a/mainwindow.ui b/mainwindow.ui index 131449fb..ff6aef82 100755 --- a/mainwindow.ui +++ b/mainwindow.ui @@ -1286,22 +1286,22 @@ - Up + up - Right + right - Down + down - Left + left @@ -1346,7 +1346,10 @@ - -99 + -999 + + + 999 @@ -1412,7 +1415,17 @@ - + + + + + 0 + 0 + 0 + + + + diff --git a/map.h b/map.h index 12b62c01..9570fce1 100755 --- a/map.h +++ b/map.h @@ -180,7 +180,7 @@ public: QMap> events; QList connections; - QMap connection_items; + QList connection_items; QPixmap renderConnection(Connection); QImage border_image; From 5301b299e2265bb7c43d5a5e2e697baf3d8e1ef7 Mon Sep 17 00:00:00 2001 From: Marcus Huderle Date: Sat, 10 Mar 2018 10:09:19 -0800 Subject: [PATCH 10/20] Support adding/removing connections via buttons --- editor.cpp | 126 +++++++++++++++++++++++++++++++++---------------- editor.h | 3 ++ mainwindow.cpp | 10 ++++ mainwindow.h | 4 ++ mainwindow.ui | 104 ++++++++++++++++++++++++++++++++++++++-- 5 files changed, 203 insertions(+), 44 deletions(-) diff --git a/editor.cpp b/editor.cpp index d4dcf0a0..62f82804 100755 --- a/editor.cpp +++ b/editor.cpp @@ -97,6 +97,7 @@ void Editor::setEditingConnections() { ui->comboBox_ConnectedMap->clear(); ui->comboBox_ConnectedMap->addItems(*project->mapNames); ui->comboBox_ConnectedMap->blockSignals(false); + ui->label_NumConnections->setText(QString::number(map->connections.length())); setConnectionsVisibility(false); if (current_connection_edit_item) { onConnectionOffsetChanged(current_connection_edit_item->connection->offset.toInt()); @@ -195,6 +196,9 @@ void Editor::setConnectionEditControlsEnabled(bool enabled) { } void Editor::onConnectionItemSelected(ConnectionPixmapItem* connectionItem) { + if (!connectionItem) + return; + for (ConnectionPixmapItem* item : connection_edit_items) { bool isSelectedItem = item == connectionItem; int zValue = isSelectedItem ? 0 : -1; @@ -372,39 +376,7 @@ void Editor::displayMapConnections() { if (connection->direction == "dive" || connection->direction == "emerge") { continue; } - Map *connected_map = project->getMap(connection->map_name); - QPixmap pixmap = connected_map->renderConnection(*connection); - int offset = connection->offset.toInt(nullptr, 0); - int x = 0, y = 0; - if (connection->direction == "up") { - x = offset * 16; - y = -pixmap.height(); - } else if (connection->direction == "down") { - x = offset * 16; - y = map->getHeight() * 16; - } else if (connection->direction == "left") { - x = -pixmap.width(); - y = offset * 16; - } else if (connection->direction == "right") { - x = map->getWidth() * 16; - y = offset * 16; - } - - QGraphicsPixmapItem *item = new QGraphicsPixmapItem(pixmap); - item->setZValue(-1); - item->setX(x); - item->setY(y); - scene->addItem(item); - map->connection_items.append(item); - - ConnectionPixmapItem *connection_edit_item = new ConnectionPixmapItem(pixmap, connection, x, y); - connection_edit_item->setX(x); - connection_edit_item->setY(y); - connection_edit_item->setZValue(-1); - scene->addItem(connection_edit_item); - connect(connection_edit_item, SIGNAL(connectionMoved(int)), this, SLOT(onConnectionOffsetChanged(int))); - connect(connection_edit_item, SIGNAL(connectionItemSelected(ConnectionPixmapItem*)), this, SLOT(onConnectionItemSelected(ConnectionPixmapItem*))); - connection_edit_items.append(connection_edit_item); + createConnectionItem(connection, false); } if (!connection_edit_items.empty()) { @@ -412,6 +384,43 @@ void Editor::displayMapConnections() { } } +void Editor::createConnectionItem(Connection* connection, bool hide) { + Map *connected_map = project->getMap(connection->map_name); + QPixmap pixmap = connected_map->renderConnection(*connection); + int offset = connection->offset.toInt(nullptr, 0); + int x = 0, y = 0; + if (connection->direction == "up") { + x = offset * 16; + y = -pixmap.height(); + } else if (connection->direction == "down") { + x = offset * 16; + y = map->getHeight() * 16; + } else if (connection->direction == "left") { + x = -pixmap.width(); + y = offset * 16; + } else if (connection->direction == "right") { + x = map->getWidth() * 16; + y = offset * 16; + } + + QGraphicsPixmapItem *item = new QGraphicsPixmapItem(pixmap); + item->setZValue(-1); + item->setX(x); + item->setY(y); + scene->addItem(item); + map->connection_items.append(item); + item->setVisible(!hide); + + ConnectionPixmapItem *connection_edit_item = new ConnectionPixmapItem(pixmap, connection, x, y); + connection_edit_item->setX(x); + connection_edit_item->setY(y); + connection_edit_item->setZValue(-1); + scene->addItem(connection_edit_item); + connect(connection_edit_item, SIGNAL(connectionMoved(int)), this, SLOT(onConnectionOffsetChanged(int))); + connect(connection_edit_item, SIGNAL(connectionItemSelected(ConnectionPixmapItem*)), this, SLOT(onConnectionItemSelected(ConnectionPixmapItem*))); + connection_edit_items.append(connection_edit_item); +} + void Editor::displayMapBorder() { QPixmap pixmap = map->renderBorder(); for (int y = -6; y < map->getHeight() + 6; y += 2) @@ -465,13 +474,7 @@ void Editor::updateConnectionMap(QString mapName, QString direction) { return; if (mapName.isEmpty()) { - map->connections.removeOne(current_connection_edit_item->connection); - connection_edit_items.removeOne(current_connection_edit_item); - scene->removeItem(current_connection_edit_item); - delete current_connection_edit_item; - current_connection_edit_item = NULL; - setConnectionEditControlsEnabled(false); - ui->spinBox_ConnectionOffset->setValue(0); + removeCurrentConnection(); return; } else { setConnectionEditControlsEnabled(true); @@ -481,6 +484,49 @@ void Editor::updateConnectionMap(QString mapName, QString direction) { setCurrentConnectionDirection(direction); } +void Editor::addNewConnection() { + // Find direction with least number of connections. + QMap directionCounts = QMap({{"up", 0}, {"right", 0}, {"down", 0}, {"left", 0}}); + for (Connection* connection : map->connections) { + directionCounts[connection->direction]++; + } + QString minDirection = "up"; + int minCount = INT_MAX; + for (QString direction : directionCounts.keys()) { + if (directionCounts[direction] < minCount) { + minDirection = direction; + minCount = directionCounts[direction]; + } + } + + Connection* newConnection = new Connection; + newConnection->direction = minDirection; + newConnection->offset = "0"; + newConnection->map_name = project->mapNames->first(); + map->connections.append(newConnection); + createConnectionItem(newConnection, true); + onConnectionItemSelected(connection_edit_items.last()); + ui->label_NumConnections->setText(QString::number(map->connections.length())); +} + +void Editor::removeCurrentConnection() { + if (!current_connection_edit_item) + return; + + map->connections.removeOne(current_connection_edit_item->connection); + connection_edit_items.removeOne(current_connection_edit_item); + scene->removeItem(current_connection_edit_item); + delete current_connection_edit_item; + current_connection_edit_item = NULL; + setConnectionEditControlsEnabled(false); + ui->spinBox_ConnectionOffset->setValue(0); + ui->label_NumConnections->setText(QString::number(map->connections.length())); + + if (connection_edit_items.length() > 0) { + onConnectionItemSelected(connection_edit_items.last()); + } +} + void MetatilesPixmapItem::paintTileChanged(Map *map) { draw(); } diff --git a/editor.h b/editor.h index 60a91d64..590d3bcf 100755 --- a/editor.h +++ b/editor.h @@ -51,6 +51,8 @@ public: void setConnectionsVisibility(bool visible); void updateConnectionOffset(int offset); void updateConnectionMap(QString mapName, QString direction); + void addNewConnection(); + void removeCurrentConnection(); DraggablePixmapItem *addMapObject(Event *event); void selectMapObject(DraggablePixmapItem *object); @@ -92,6 +94,7 @@ private: void setBorderItemsVisible(bool, qreal = 1); void setConnectionEditControlValues(Connection*); void setConnectionEditControlsEnabled(bool); + void createConnectionItem(Connection* connection, bool hide); private slots: void mouseEvent_map(QGraphicsSceneMouseEvent *event, MapPixmapItem *item); diff --git a/mainwindow.cpp b/mainwindow.cpp index 7ebc21d8..8bd0dd4b 100755 --- a/mainwindow.cpp +++ b/mainwindow.cpp @@ -780,3 +780,13 @@ void MainWindow::on_comboBox_ConnectedMap_currentTextChanged(const QString &mapN { editor->updateConnectionMap(mapName, ui->comboBox_ConnectionDirection->currentText().toLower()); } + +void MainWindow::on_pushButton_AddConnection_clicked() +{ + editor->addNewConnection(); +} + +void MainWindow::on_pushButton_RemoveConnection_clicked() +{ + editor->removeCurrentConnection(); +} diff --git a/mainwindow.h b/mainwindow.h index fd72b873..3f6c84d8 100755 --- a/mainwindow.h +++ b/mainwindow.h @@ -80,6 +80,10 @@ private slots: void on_comboBox_ConnectedMap_currentTextChanged(const QString &mapName); + void on_pushButton_AddConnection_clicked(); + + void on_pushButton_RemoveConnection_clicked(); + private: Ui::MainWindow *ui; QStandardItemModel *mapListModel; diff --git a/mainwindow.ui b/mainwindow.ui index ff6aef82..c2269b6b 100755 --- a/mainwindow.ui +++ b/mainwindow.ui @@ -60,7 +60,7 @@ - 0 + 3 false @@ -1246,7 +1246,7 @@ 0 - + @@ -1369,7 +1369,7 @@ - + QFrame::StyledPanel @@ -1410,7 +1410,7 @@ 0 0 826 - 621 + 587 @@ -1486,6 +1486,102 @@ + + + + + 0 + 0 + + + + + 0 + 32 + + + + QFrame::StyledPanel + + + QFrame::Raised + + + + 4 + + + 4 + + + 4 + + + 4 + + + 4 + + + + + + 0 + 0 + + + + + + + + :/icons/add.ico + + + + + + + + + + + + :/icons/delete.ico + + + + + + + + Number of Connections: + + + + + + + + + + + + + + Qt::Horizontal + + + + 40 + 20 + + + + + + + From 6f71c156298875e0533cc35fc4afea3e02bcf45a Mon Sep 17 00:00:00 2001 From: Marcus Huderle Date: Sat, 10 Mar 2018 11:25:34 -0800 Subject: [PATCH 11/20] Add dive/emerge map pickers --- editor.cpp | 94 ++++++++++++-- editor.h | 5 + mainwindow.cpp | 10 ++ mainwindow.h | 4 + mainwindow.ui | 334 ++++++++++++++++++++++++++++++------------------- 5 files changed, 310 insertions(+), 137 deletions(-) diff --git a/editor.cpp b/editor.cpp index 62f82804..a2680c5d 100755 --- a/editor.cpp +++ b/editor.cpp @@ -93,12 +93,10 @@ void Editor::setEditingConnections() { map_item->draw(); map_item->setVisible(true); map_item->setEnabled(false); - ui->comboBox_ConnectedMap->blockSignals(true); - ui->comboBox_ConnectedMap->clear(); - ui->comboBox_ConnectedMap->addItems(*project->mapNames); - ui->comboBox_ConnectedMap->blockSignals(false); + populateConnectionMapPickers(); ui->label_NumConnections->setText(QString::number(map->connections.length())); setConnectionsVisibility(false); + setDiveEmergeControls(); if (current_connection_edit_item) { onConnectionOffsetChanged(current_connection_edit_item->connection->offset.toInt()); updateConnectionMap(current_connection_edit_item->connection->map_name, current_connection_edit_item->connection->direction); @@ -114,6 +112,39 @@ void Editor::setEditingConnections() { setConnectionItemsVisible(true); } +void Editor::setDiveEmergeControls() { + ui->comboBox_DiveMap->blockSignals(true); + ui->comboBox_EmergeMap->blockSignals(true); + ui->comboBox_DiveMap->setCurrentText(""); + ui->comboBox_EmergeMap->setCurrentText(""); + for (Connection* connection : map->connections) { + if (connection->direction == "dive") { + ui->comboBox_DiveMap->setCurrentText(connection->map_name); + } else if (connection->direction == "emerge") { + ui->comboBox_EmergeMap->setCurrentText(connection->map_name); + } + } + ui->comboBox_DiveMap->blockSignals(false); + ui->comboBox_EmergeMap->blockSignals(false); +} + +void Editor::populateConnectionMapPickers() { + ui->comboBox_ConnectedMap->blockSignals(true); + ui->comboBox_DiveMap->blockSignals(true); + ui->comboBox_EmergeMap->blockSignals(true); + + ui->comboBox_ConnectedMap->clear(); + ui->comboBox_ConnectedMap->addItems(*project->mapNames); + ui->comboBox_DiveMap->clear(); + ui->comboBox_DiveMap->addItems(*project->mapNames); + ui->comboBox_EmergeMap->clear(); + ui->comboBox_EmergeMap->addItems(*project->mapNames); + + ui->comboBox_ConnectedMap->blockSignals(false); + ui->comboBox_DiveMap->blockSignals(true); + ui->comboBox_EmergeMap->blockSignals(true); +} + void Editor::setConnectionItemsVisible(bool visible) { for (ConnectionPixmapItem* item : connection_edit_items) { item->setVisible(visible); @@ -176,13 +207,17 @@ void Editor::onConnectionOffsetChanged(int newOffset) { } void Editor::setConnectionEditControlValues(Connection* connection) { + QString mapName = connection ? connection->map_name : ""; + QString direction = connection ? connection->direction : ""; + int offset = connection ? connection->offset.toInt() : 0; + ui->comboBox_ConnectedMap->blockSignals(true); ui->comboBox_ConnectionDirection->blockSignals(true); ui->spinBox_ConnectionOffset->blockSignals(true); - ui->comboBox_ConnectedMap->setCurrentText(connection->map_name); - ui->comboBox_ConnectionDirection->setCurrentText(connection->direction); - ui->spinBox_ConnectionOffset->setValue(connection->offset.toInt()); + ui->comboBox_ConnectedMap->setCurrentText(mapName); + ui->comboBox_ConnectionDirection->setCurrentText(direction); + ui->spinBox_ConnectionOffset->setValue(offset); ui->comboBox_ConnectedMap->blockSignals(false); ui->comboBox_ConnectionDirection->blockSignals(false); @@ -193,6 +228,10 @@ void Editor::setConnectionEditControlsEnabled(bool enabled) { ui->comboBox_ConnectionDirection->setEnabled(enabled); ui->comboBox_ConnectedMap->setEnabled(enabled); ui->spinBox_ConnectionOffset->setEnabled(enabled); + + if (!enabled) { + setConnectionEditControlValues(false); + } } void Editor::onConnectionItemSelected(ConnectionPixmapItem* connectionItem) { @@ -527,6 +566,47 @@ void Editor::removeCurrentConnection() { } } +void Editor::updateDiveMap(QString mapName) { + updateDiveEmergeMap(mapName, "dive"); +} + +void Editor::updateEmergeMap(QString mapName) { + updateDiveEmergeMap(mapName, "emerge"); +} + +void Editor::updateDiveEmergeMap(QString mapName, QString direction) { + if (!mapName.isEmpty() && !project->mapNamesToMapConstants->contains(mapName)) { + qDebug() << "Invalid " << direction << " map connection: " << mapName; + return; + } + + Connection* connection = NULL; + for (Connection* conn : map->connections) { + if (conn->direction == direction) { + connection = conn; + break; + } + } + + if (mapName.isEmpty()) { + // Remove dive/emerge connection + if (connection) { + map->connections.removeOne(connection); + } + } else { + if (!connection) { + connection = new Connection; + connection->direction = direction; + connection->offset = "0"; + map->connections.append(connection); + } + + connection->map_name = mapName; + } + + ui->label_NumConnections->setText(QString::number(map->connections.length())); +} + void MetatilesPixmapItem::paintTileChanged(Map *map) { draw(); } diff --git a/editor.h b/editor.h index 590d3bcf..a9b43624 100755 --- a/editor.h +++ b/editor.h @@ -53,6 +53,8 @@ public: void updateConnectionMap(QString mapName, QString direction); void addNewConnection(); void removeCurrentConnection(); + void updateDiveMap(QString mapName); + void updateEmergeMap(QString mapName); DraggablePixmapItem *addMapObject(Event *event); void selectMapObject(DraggablePixmapItem *object); @@ -95,6 +97,9 @@ private: void setConnectionEditControlValues(Connection*); void setConnectionEditControlsEnabled(bool); void createConnectionItem(Connection* connection, bool hide); + void populateConnectionMapPickers(); + void setDiveEmergeControls(); + void updateDiveEmergeMap(QString mapName, QString direction); private slots: void mouseEvent_map(QGraphicsSceneMouseEvent *event, MapPixmapItem *item); diff --git a/mainwindow.cpp b/mainwindow.cpp index 8bd0dd4b..d7f076b3 100755 --- a/mainwindow.cpp +++ b/mainwindow.cpp @@ -790,3 +790,13 @@ void MainWindow::on_pushButton_RemoveConnection_clicked() { editor->removeCurrentConnection(); } + +void MainWindow::on_comboBox_DiveMap_currentTextChanged(const QString &mapName) +{ + editor->updateDiveMap(mapName); +} + +void MainWindow::on_comboBox_EmergeMap_currentTextChanged(const QString &mapName) +{ + editor->updateEmergeMap(mapName); +} diff --git a/mainwindow.h b/mainwindow.h index 3f6c84d8..3b4c02dc 100755 --- a/mainwindow.h +++ b/mainwindow.h @@ -84,6 +84,10 @@ private slots: void on_pushButton_RemoveConnection_clicked(); + void on_comboBox_DiveMap_currentTextChanged(const QString &mapName); + + void on_comboBox_EmergeMap_currentTextChanged(const QString &mapName); + private: Ui::MainWindow *ui; QStandardItemModel *mapListModel; diff --git a/mainwindow.ui b/mainwindow.ui index c2269b6b..57d6ad54 100755 --- a/mainwindow.ui +++ b/mainwindow.ui @@ -60,7 +60,7 @@ - 3 + 0 false @@ -1247,6 +1247,102 @@ 0 + + + + 0 + 0 + + + + + 0 + 32 + + + + QFrame::StyledPanel + + + QFrame::Raised + + + + 4 + + + 4 + + + 4 + + + 4 + + + 4 + + + + + + 0 + 0 + + + + + + + + :/icons/add.ico + + + + + + + + + + + + :/icons/delete.ico + + + + + + + + Number of Connections: + + + + + + + + + + + + + + Qt::Horizontal + + + + 40 + 20 + + + + + + + + @@ -1369,7 +1465,7 @@ - + QFrame::StyledPanel @@ -1393,7 +1489,7 @@ 0 - + @@ -1410,10 +1506,49 @@ 0 0 826 - 587 + 557 + + + + Qt::Horizontal + + + + 40 + 20 + + + + + + + + Qt::Vertical + + + + 20 + 40 + + + + + + + + Qt::Vertical + + + + 20 + 40 + + + + @@ -1440,145 +1575,84 @@ - - - - Qt::Horizontal - - - - 40 - 20 - - - - - - - - Qt::Vertical - - - - 20 - 40 - - - - - - - - Qt::Vertical - - - - 20 - 40 - - - - - - - - - - - - 0 - 0 - - - - - 0 - 32 - - - - QFrame::StyledPanel - - - QFrame::Raised - - - - 4 - - - 4 - - - 4 - - - 4 - - - 4 - - - + + - + 0 0 - - + + QFrame::StyledPanel - - - :/icons/add.ico - + + QFrame::Raised + + + 4 + + + 4 + + + 4 + + + 4 + + + 4 + + + + + Dive Map + + + + + + + true + + + + + + + Emerge Map + + + + + + + true + + + + + + + Qt::Horizontal + + + + 40 + 20 + + + + + - - - - - - - - :/icons/delete.ico - - - - - - - - Number of Connections: - - - - - - - - - - - - - - Qt::Horizontal - - - - 40 - 20 - - - - From 9b0f6867815d23bd9b182995a17303e3e29412fb Mon Sep 17 00:00:00 2001 From: Marcus Huderle Date: Sun, 11 Mar 2018 13:33:08 -0700 Subject: [PATCH 12/20] Properly support saving map connections --- editor.cpp | 1 + mainwindow.cpp | 1 + project.cpp | 106 ++++++++++++++++++++++++++++++++++++++++--------- project.h | 5 +++ 4 files changed, 94 insertions(+), 19 deletions(-) diff --git a/editor.cpp b/editor.cpp index a2680c5d..d2ea5c65 100755 --- a/editor.cpp +++ b/editor.cpp @@ -409,6 +409,7 @@ void Editor::displayMapConnections() { for (ConnectionPixmapItem* item : connection_edit_items) { delete item; } + current_connection_edit_item = NULL; connection_edit_items.clear(); for (Connection *connection : map->connections) { diff --git a/mainwindow.cpp b/mainwindow.cpp index d7f076b3..f55a0b04 100755 --- a/mainwindow.cpp +++ b/mainwindow.cpp @@ -289,6 +289,7 @@ void MainWindow::loadDataStructures() { project->readItemNames(); project->readFlagNames(); project->readVarNames(); + project->readMapsWithConnections(); } void MainWindow::populateMapList() { diff --git a/project.cpp b/project.cpp index 9053b164..dc4dd11b 100755 --- a/project.cpp +++ b/project.cpp @@ -197,7 +197,14 @@ void Project::saveMapHeader(Map *map) { text += QString("\t.4byte %1\n").arg(map->attributes_label); text += QString("\t.4byte %1\n").arg(map->events_label); text += QString("\t.4byte %1\n").arg(map->scripts_label); + + if (map->connections.length() == 0) { + map->connections_label = "0x0"; + } else { + map->connections_label = QString("%1_MapConnections").arg(map->name); + } text += QString("\t.4byte %1\n").arg(map->connections_label); + text += QString("\t.2byte %1\n").arg(map->song); text += QString("\t.2byte %1\n").arg(map->index); text += QString("\t.byte %1\n").arg(map->location); @@ -211,27 +218,45 @@ void Project::saveMapHeader(Map *map) { } void Project::saveMapConnections(Map *map) { - QString connections_path = root + "/data/maps/" + map->name + "/connections.inc"; - QString connectionsListLabel = QString("%1_MapConnectionsList").arg(map->name); - int numValidConnections = 0; - QString text = ""; - text += QString("%1::\n").arg(connectionsListLabel); - for (Connection* connection : map->connections) { - if (mapNamesToMapConstants->contains(connection->map_name)) { - text += QString("\tconnection %1, %2, %3\n") - .arg(connection->direction) - .arg(connection->offset) - .arg(mapNamesToMapConstants->value(connection->map_name)); - numValidConnections++; - } else { - qDebug() << QString("Failed to write map connection. %1 not a valid map name").arg(connection->map_name); + QString path = root + "/data/maps/" + map->name + "/connections.inc"; + if (map->connections.length() > 0) { + QString text = ""; + QString connectionsListLabel = QString("%1_MapConnectionsList").arg(map->name); + int numValidConnections = 0; + text += QString("%1::\n").arg(connectionsListLabel); + for (Connection* connection : map->connections) { + if (mapNamesToMapConstants->contains(connection->map_name)) { + text += QString("\tconnection %1, %2, %3\n") + .arg(connection->direction) + .arg(connection->offset) + .arg(mapNamesToMapConstants->value(connection->map_name)); + numValidConnections++; + } else { + qDebug() << QString("Failed to write map connection. %1 not a valid map name").arg(connection->map_name); + } + } + text += QString("\n"); + text += QString("%1::\n").arg(map->connections_label); + text += QString("\t.4byte %1\n").arg(numValidConnections); + text += QString("\t.4byte %1\n").arg(connectionsListLabel); + saveTextFile(path, text); + } else { + deleteFile(path); + } + + updateMapsWithConnections(map); +} + +void Project::updateMapsWithConnections(Map *map) { + if (map->connections.length() > 0) { + if (!mapsWithConnections.contains(map->name)) { + mapsWithConnections.append(map->name); + } + } else { + if (mapsWithConnections.contains(map->name)) { + mapsWithConnections.removeOne(map->name); } } - text += QString("\n"); - text += QString("%1::\n").arg(map->connections_label); - text += QString("\t.4byte %1\n").arg(numValidConnections); - text += QString("\t.4byte %1\n").arg(connectionsListLabel); - saveTextFile(connections_path, text); } void Project::readMapAttributesTable() { @@ -728,6 +753,7 @@ void Project::saveAllDataStructures() { saveAllMapAttributes(); saveMapGroupsTable(); saveMapConstantsHeader(); + saveMapsWithConnections(); } void Project::loadTilesetAssets(Tileset* tileset) { @@ -939,6 +965,13 @@ void Project::appendTextFile(QString path, QString text) { } } +void Project::deleteFile(QString path) { + QFile file(path); + if (file.exists() && !file.remove()) { + qDebug() << QString("Could not delete file '%1': ").arg(path) + file.errorString(); + } +} + void Project::readMapGroups() { QString text = readTextFile(root + "/data/maps/_groups.inc"); if (text.isNull()) { @@ -1124,6 +1157,41 @@ void Project::readCDefinesSorted(QString filepath, QStringList prefixes, QString } } +void Project::readMapsWithConnections() { + QString path = root + "/data/maps/connections.inc"; + QString text = readTextFile(path); + if (text.isNull()) { + return; + } + + mapsWithConnections.clear(); + QRegularExpression re("data\\/maps\\/(?\\w+)\\/connections.inc"); + QList* includes = parseAsm(text); + for (QStringList values : *includes) { + if (values.length() != 2) + continue; + + QRegularExpressionMatch match = re.match(values.value(1)); + if (match.hasMatch()) { + QString mapName = match.captured("mapName"); + mapsWithConnections.append(mapName); + } + } +} + +void Project::saveMapsWithConnections() { + QString path = root + "/data/maps/connections.inc"; + QString text = ""; + for (QString mapName : mapsWithConnections) { + if (mapNamesToMapConstants->contains(mapName)) { + text += QString("\t.include \"data/maps/%1/connections.inc\"\n").arg(mapName); + } else { + qDebug() << QString("Failed to write connection include. %1 not a valid map name").arg(mapName); + } + } + saveTextFile(path, text); +} + QStringList Project::getSongNames() { QStringList names; QString text = readTextFile(root + "/include/constants/songs.h"); diff --git a/project.h b/project.h index 0c064444..58502c2f 100755 --- a/project.h +++ b/project.h @@ -26,6 +26,7 @@ public: QStringList *itemNames = NULL; QStringList *flagNames = NULL; QStringList *varNames = NULL; + QStringList mapsWithConnections; QMap *map_cache; Map* loadMap(QString); @@ -41,6 +42,7 @@ public: QString readTextFile(QString path); void saveTextFile(QString path, QString text); void appendTextFile(QString path, QString text); + void deleteFile(QString path); void readMapGroups(); Map* addNewMapToGroup(QString mapName, int groupNum); @@ -53,6 +55,7 @@ public: void readMapAttributesTable(); void readAllMapAttributes(); void readMapAttributes(Map*); + void readMapsWithConnections(); void getTilesets(Map*); void loadTilesetAssets(Tileset*); @@ -98,6 +101,8 @@ private: QString getMapAssetsFilepath(); void saveMapHeader(Map*); void saveMapConnections(Map*); + void updateMapsWithConnections(Map*); + void saveMapsWithConnections(); void saveMapAttributesTable(); void updateMapAttributes(Map* map); void readCDefinesSorted(QString, QStringList, QStringList*); From f47e3bf4ea9777516dc405f6a26fd80262535158 Mon Sep 17 00:00:00 2001 From: Marcus Huderle Date: Sun, 11 Mar 2018 14:01:29 -0700 Subject: [PATCH 13/20] Limit connection offsets to reasonable values --- editor.cpp | 24 +++++++++++++++++++++++- editor.h | 8 +++++++- 2 files changed, 30 insertions(+), 2 deletions(-) diff --git a/editor.cpp b/editor.cpp index d2ea5c65..69bc9187 100755 --- a/editor.cpp +++ b/editor.cpp @@ -257,6 +257,8 @@ void Editor::onConnectionItemSelected(ConnectionPixmapItem* connectionItem) { current_connection_edit_item->setZValue(0); setConnectionEditControlsEnabled(true); setConnectionEditControlValues(current_connection_edit_item->connection); + ui->spinBox_ConnectionOffset->setMaximum(current_connection_edit_item->getMaxOffset()); + ui->spinBox_ConnectionOffset->setMinimum(current_connection_edit_item->getMinOffset()); } void Editor::onConnectionDirectionChanged(QString newDirection) { @@ -451,7 +453,7 @@ void Editor::createConnectionItem(Connection* connection, bool hide) { map->connection_items.append(item); item->setVisible(!hide); - ConnectionPixmapItem *connection_edit_item = new ConnectionPixmapItem(pixmap, connection, x, y); + ConnectionPixmapItem *connection_edit_item = new ConnectionPixmapItem(pixmap, connection, x, y, map->getWidth(), map->getHeight()); connection_edit_item->setX(x); connection_edit_item->setY(y); connection_edit_item->setZValue(-1); @@ -496,6 +498,8 @@ void Editor::updateConnectionOffset(int offset) { return; current_connection_edit_item->blockSignals(true); + offset = qMin(offset, current_connection_edit_item->getMaxOffset()); + offset = qMax(offset, current_connection_edit_item->getMinOffset()); current_connection_edit_item->connection->offset = QString::number(offset); if (current_connection_edit_item->connection->direction == "up" || current_connection_edit_item->connection->direction == "down") { current_connection_edit_item->setX(current_connection_edit_item->initialX + (offset - current_connection_edit_item->initialOffset) * 16); @@ -690,6 +694,18 @@ void CollisionMetatilesPixmapItem::updateCurHoveredMetatile(QPointF pos) { } } +int ConnectionPixmapItem::getMinOffset() { + if (connection->direction == "up" || connection->direction == "down") + return 1 - (this->pixmap().width() / 16); + else + return 1 - (this->pixmap().height() / 16); +} +int ConnectionPixmapItem::getMaxOffset() { + if (connection->direction == "up" || connection->direction == "down") + return baseMapWidth - 1; + else + return baseMapHeight - 1; +} QVariant ConnectionPixmapItem::itemChange(GraphicsItemChange change, const QVariant &value) { if (change == ItemPositionChange) { @@ -700,6 +716,9 @@ QVariant ConnectionPixmapItem::itemChange(GraphicsItemChange change, const QVari if (connection->direction == "up" || connection->direction == "down") { x = round(newPos.x() / 16) * 16; newOffset += (x - initialX) / 16; + newOffset = qMin(newOffset, this->getMaxOffset()); + newOffset = qMax(newOffset, this->getMinOffset()); + x = newOffset * 16; } else { x = initialX; @@ -708,6 +727,9 @@ QVariant ConnectionPixmapItem::itemChange(GraphicsItemChange change, const QVari if (connection->direction == "right" || connection->direction == "left") { y = round(newPos.y() / 16) * 16; newOffset += (y - initialY) / 16; + newOffset = qMin(newOffset, this->getMaxOffset()); + newOffset = qMax(newOffset, this->getMinOffset()); + y = newOffset * 16; } else { y = initialY; diff --git a/editor.h b/editor.h index a9b43624..3212955f 100755 --- a/editor.h +++ b/editor.h @@ -270,7 +270,7 @@ protected: class ConnectionPixmapItem : public QObject, public QGraphicsPixmapItem { Q_OBJECT public: - ConnectionPixmapItem(QPixmap pixmap, Connection* connection, int x, int y): QGraphicsPixmapItem(pixmap) { + ConnectionPixmapItem(QPixmap pixmap, Connection* connection, int x, int y, int baseMapWidth, int baseMapHeight): QGraphicsPixmapItem(pixmap) { this->basePixmap = pixmap; this->connection = connection; setFlag(ItemIsMovable); @@ -278,6 +278,8 @@ public: this->initialX = x; this->initialY = y; this->initialOffset = connection->offset.toInt(); + this->baseMapWidth = baseMapWidth; + this->baseMapHeight = baseMapHeight; } void render(qreal opacity = 1) { QPixmap newPixmap = basePixmap.copy(0, 0, basePixmap.width(), basePixmap.height()); @@ -289,11 +291,15 @@ public: } this->setPixmap(newPixmap); } + int getMinOffset(); + int getMaxOffset(); QPixmap basePixmap; Connection* connection; int initialX; int initialY; int initialOffset; + int baseMapWidth; + int baseMapHeight; protected: QVariant itemChange(GraphicsItemChange change, const QVariant &value); void mousePressEvent(QGraphicsSceneMouseEvent*); From bd2c7820210166583ab9a86f2959fbd023ae9e7c Mon Sep 17 00:00:00 2001 From: Marcus Huderle Date: Sun, 11 Mar 2018 14:20:52 -0700 Subject: [PATCH 14/20] Double-clicking on a connection will load the destination map --- editor.cpp | 19 ++++++++++++++++++- editor.h | 5 +++++ mainwindow.cpp | 6 ++++++ mainwindow.h | 1 + 4 files changed, 30 insertions(+), 1 deletion(-) diff --git a/editor.cpp b/editor.cpp index 69bc9187..d8bf7547 100755 --- a/editor.cpp +++ b/editor.cpp @@ -254,13 +254,26 @@ void Editor::onConnectionItemSelected(ConnectionPixmapItem* connectionItem) { } } current_connection_edit_item = connectionItem; - current_connection_edit_item->setZValue(0); setConnectionEditControlsEnabled(true); setConnectionEditControlValues(current_connection_edit_item->connection); ui->spinBox_ConnectionOffset->setMaximum(current_connection_edit_item->getMaxOffset()); ui->spinBox_ConnectionOffset->setMinimum(current_connection_edit_item->getMinOffset()); } +void Editor::setSelectedConnectionFromMap(QString mapName) { + // Search for the first connection that connects to the given map map. + for (ConnectionPixmapItem* item : connection_edit_items) { + if (item->connection->map_name == mapName) { + onConnectionItemSelected(item); + break; + } + } +} + +void Editor::onConnectionItemDoubleClicked(ConnectionPixmapItem* connectionItem) { + emit loadMapRequested(connectionItem->connection->map_name, map->name); +} + void Editor::onConnectionDirectionChanged(QString newDirection) { ui->comboBox_ConnectionDirection->blockSignals(true); ui->comboBox_ConnectionDirection->setCurrentText(newDirection); @@ -460,6 +473,7 @@ void Editor::createConnectionItem(Connection* connection, bool hide) { scene->addItem(connection_edit_item); connect(connection_edit_item, SIGNAL(connectionMoved(int)), this, SLOT(onConnectionOffsetChanged(int))); connect(connection_edit_item, SIGNAL(connectionItemSelected(ConnectionPixmapItem*)), this, SLOT(onConnectionItemSelected(ConnectionPixmapItem*))); + connect(connection_edit_item, SIGNAL(connectionItemDoubleClicked(ConnectionPixmapItem*)), this, SLOT(onConnectionItemDoubleClicked(ConnectionPixmapItem*))); connection_edit_items.append(connection_edit_item); } @@ -746,6 +760,9 @@ QVariant ConnectionPixmapItem::itemChange(GraphicsItemChange change, const QVari void ConnectionPixmapItem::mousePressEvent(QGraphicsSceneMouseEvent* event) { emit connectionItemSelected(this); } +void ConnectionPixmapItem::mouseDoubleClickEvent(QGraphicsSceneMouseEvent*) { + emit connectionItemDoubleClicked(this); +} void ElevationMetatilesPixmapItem::updateCurHoveredMetatile(QPointF pos) { int x = ((int)pos.x()) / 16; diff --git a/editor.h b/editor.h index 3212955f..bf38920e 100755 --- a/editor.h +++ b/editor.h @@ -55,6 +55,7 @@ public: void removeCurrentConnection(); void updateDiveMap(QString mapName); void updateEmergeMap(QString mapName); + void setSelectedConnectionFromMap(QString mapName); DraggablePixmapItem *addMapObject(Event *event); void selectMapObject(DraggablePixmapItem *object); @@ -106,11 +107,13 @@ private slots: void mouseEvent_collision(QGraphicsSceneMouseEvent *event, CollisionPixmapItem *item); void onConnectionOffsetChanged(int newOffset); void onConnectionItemSelected(ConnectionPixmapItem* connectionItem); + void onConnectionItemDoubleClicked(ConnectionPixmapItem* connectionItem); void onConnectionDirectionChanged(QString newDirection); signals: void objectsChanged(); void selectedObjectsChanged(); + void loadMapRequested(QString, QString); }; @@ -303,8 +306,10 @@ public: protected: QVariant itemChange(GraphicsItemChange change, const QVariant &value); void mousePressEvent(QGraphicsSceneMouseEvent*); + void mouseDoubleClickEvent(QGraphicsSceneMouseEvent*); signals: void connectionItemSelected(ConnectionPixmapItem* connectionItem); + void connectionItemDoubleClicked(ConnectionPixmapItem* connectionItem); void connectionMoved(int offset); }; diff --git a/mainwindow.cpp b/mainwindow.cpp index f55a0b04..dbb6a037 100755 --- a/mainwindow.cpp +++ b/mainwindow.cpp @@ -29,6 +29,7 @@ MainWindow::MainWindow(QWidget *parent) : editor = new Editor(ui); connect(editor, SIGNAL(objectsChanged()), this, SLOT(updateSelectedObjects())); connect(editor, SIGNAL(selectedObjectsChanged()), this, SLOT(updateSelectedObjects())); + connect(editor, SIGNAL(loadMapRequested(QString, QString)), this, SLOT(onLoadMapRequested(QString, QString))); on_toolButton_Paint_clicked(); @@ -754,6 +755,11 @@ void MainWindow::checkToolButtons() { ui->toolButton_Dropper->setChecked(editor->map_edit_mode == "pick"); } +void MainWindow::onLoadMapRequested(QString mapName, QString fromMapName) { + setMap(mapName); + editor->setSelectedConnectionFromMap(fromMapName); +} + void MainWindow::onMapChanged(Map *map) { updateMapList(); } diff --git a/mainwindow.h b/mainwindow.h index 3b4c02dc..5c01c2da 100755 --- a/mainwindow.h +++ b/mainwindow.h @@ -36,6 +36,7 @@ private slots: void undo(); void redo(); + void onLoadMapRequested(QString, QString); void onMapChanged(Map *map); void on_action_Save_triggered(); From dec99c8cac1cdd8a0048beeaa57f5df445eba452 Mon Sep 17 00:00:00 2001 From: Marcus Huderle Date: Sun, 11 Mar 2018 15:21:01 -0700 Subject: [PATCH 15/20] Fix bug where saving shared map assets wouldn't work --- project.cpp | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/project.cpp b/project.cpp index dc4dd11b..29cbe6ae 100755 --- a/project.cpp +++ b/project.cpp @@ -740,7 +740,9 @@ void Project::saveMap(Map *map) { } void Project::updateMapAttributes(Map* map) { - mapAttributesTableMaster.insert(map->index.toInt(nullptr, 0), map->name); + if (!mapAttributesTableMaster.contains(map->index.toInt())) { + mapAttributesTableMaster.insert(map->index.toInt(), map->name); + } // Deep copy QMap attrs = mapAttributes.value(map->name); From ad7b9ca7b34617d1b310c8c7ea1ad257360a6279 Mon Sep 17 00:00:00 2001 From: Marcus Huderle Date: Sun, 11 Mar 2018 15:59:21 -0700 Subject: [PATCH 16/20] Some cleanup, and disable connection controls when loading map with no connections --- editor.cpp | 100 +++++++++++++++++++++++++------------------------ editor.h | 4 +- mainwindow.cpp | 2 +- 3 files changed, 54 insertions(+), 52 deletions(-) diff --git a/editor.cpp b/editor.cpp index d8bf7547..fdf869b4 100755 --- a/editor.cpp +++ b/editor.cpp @@ -97,9 +97,11 @@ void Editor::setEditingConnections() { ui->label_NumConnections->setText(QString::number(map->connections.length())); setConnectionsVisibility(false); setDiveEmergeControls(); - if (current_connection_edit_item) { - onConnectionOffsetChanged(current_connection_edit_item->connection->offset.toInt()); - updateConnectionMap(current_connection_edit_item->connection->map_name, current_connection_edit_item->connection->direction); + setConnectionEditControlsEnabled(selected_connection_item != NULL); + if (selected_connection_item) { + onConnectionOffsetChanged(selected_connection_item->connection->offset.toInt()); + setConnectionMap(selected_connection_item->connection->map_name); + setCurrentConnectionDirection(selected_connection_item->connection->direction); } } if (collision_item) { @@ -160,44 +162,45 @@ void Editor::setBorderItemsVisible(bool visible, qreal opacity) { } void Editor::setCurrentConnectionDirection(QString curDirection) { - if (!current_connection_edit_item) + if (!selected_connection_item) return; - current_connection_edit_item->connection->direction = curDirection; - Map *connected_map = project->getMap(current_connection_edit_item->connection->map_name); - QPixmap pixmap = connected_map->renderConnection(*current_connection_edit_item->connection); - int offset = current_connection_edit_item->connection->offset.toInt(nullptr, 0); - current_connection_edit_item->initialOffset = offset; + selected_connection_item->connection->direction = curDirection; + + Map *connected_map = project->getMap(selected_connection_item->connection->map_name); + QPixmap pixmap = connected_map->renderConnection(*selected_connection_item->connection); + int offset = selected_connection_item->connection->offset.toInt(nullptr, 0); + selected_connection_item->initialOffset = offset; int x = 0, y = 0; - if (current_connection_edit_item->connection->direction == "up") { + if (selected_connection_item->connection->direction == "up") { x = offset * 16; y = -pixmap.height(); - } else if (current_connection_edit_item->connection->direction == "down") { + } else if (selected_connection_item->connection->direction == "down") { x = offset * 16; y = map->getHeight() * 16; - } else if (current_connection_edit_item->connection->direction == "left") { + } else if (selected_connection_item->connection->direction == "left") { x = -pixmap.width(); y = offset * 16; - } else if (current_connection_edit_item->connection->direction == "right") { + } else if (selected_connection_item->connection->direction == "right") { x = map->getWidth() * 16; y = offset * 16; } - current_connection_edit_item->basePixmap = pixmap; + selected_connection_item->basePixmap = pixmap; QPainter painter(&pixmap); painter.setPen(QColor(255, 0, 255)); painter.drawRect(0, 0, pixmap.width() - 1, pixmap.height() - 1); painter.end(); - current_connection_edit_item->setPixmap(pixmap); - current_connection_edit_item->initialX = x; - current_connection_edit_item->initialY = y; - current_connection_edit_item->blockSignals(true); - current_connection_edit_item->setX(x); - current_connection_edit_item->setY(y); - current_connection_edit_item->setZValue(-1); - current_connection_edit_item->blockSignals(false); + selected_connection_item->setPixmap(pixmap); + selected_connection_item->initialX = x; + selected_connection_item->initialY = y; + selected_connection_item->blockSignals(true); + selected_connection_item->setX(x); + selected_connection_item->setY(y); + selected_connection_item->setZValue(-1); + selected_connection_item->blockSignals(false); - setConnectionEditControlValues(current_connection_edit_item->connection); + setConnectionEditControlValues(selected_connection_item->connection); } void Editor::onConnectionOffsetChanged(int newOffset) { @@ -253,11 +256,11 @@ void Editor::onConnectionItemSelected(ConnectionPixmapItem* connectionItem) { item->setPixmap(pixmap); } } - current_connection_edit_item = connectionItem; + selected_connection_item = connectionItem; setConnectionEditControlsEnabled(true); - setConnectionEditControlValues(current_connection_edit_item->connection); - ui->spinBox_ConnectionOffset->setMaximum(current_connection_edit_item->getMaxOffset()); - ui->spinBox_ConnectionOffset->setMinimum(current_connection_edit_item->getMinOffset()); + setConnectionEditControlValues(selected_connection_item->connection); + ui->spinBox_ConnectionOffset->setMaximum(selected_connection_item->getMaxOffset()); + ui->spinBox_ConnectionOffset->setMinimum(selected_connection_item->getMinOffset()); } void Editor::setSelectedConnectionFromMap(QString mapName) { @@ -424,7 +427,7 @@ void Editor::displayMapConnections() { for (ConnectionPixmapItem* item : connection_edit_items) { delete item; } - current_connection_edit_item = NULL; + selected_connection_item = NULL; connection_edit_items.clear(); for (Connection *connection : map->connections) { @@ -508,38 +511,37 @@ void Editor::displayMapGrid() { } void Editor::updateConnectionOffset(int offset) { - if (!current_connection_edit_item) + if (!selected_connection_item) return; - current_connection_edit_item->blockSignals(true); - offset = qMin(offset, current_connection_edit_item->getMaxOffset()); - offset = qMax(offset, current_connection_edit_item->getMinOffset()); - current_connection_edit_item->connection->offset = QString::number(offset); - if (current_connection_edit_item->connection->direction == "up" || current_connection_edit_item->connection->direction == "down") { - current_connection_edit_item->setX(current_connection_edit_item->initialX + (offset - current_connection_edit_item->initialOffset) * 16); + selected_connection_item->blockSignals(true); + offset = qMin(offset, selected_connection_item->getMaxOffset()); + offset = qMax(offset, selected_connection_item->getMinOffset()); + selected_connection_item->connection->offset = QString::number(offset); + if (selected_connection_item->connection->direction == "up" || selected_connection_item->connection->direction == "down") { + selected_connection_item->setX(selected_connection_item->initialX + (offset - selected_connection_item->initialOffset) * 16); } else { - current_connection_edit_item->setY(current_connection_edit_item->initialY + (offset - current_connection_edit_item->initialOffset) * 16); + selected_connection_item->setY(selected_connection_item->initialY + (offset - selected_connection_item->initialOffset) * 16); } - current_connection_edit_item->blockSignals(false); + selected_connection_item->blockSignals(false); } -void Editor::updateConnectionMap(QString mapName, QString direction) { +void Editor::setConnectionMap(QString mapName) { if (!mapName.isEmpty() && !project->mapNames->contains(mapName)) { qDebug() << "Invalid map name " << mapName << " specified for connection."; return; } - if (!current_connection_edit_item) + if (!selected_connection_item) return; if (mapName.isEmpty()) { removeCurrentConnection(); return; - } else { - setConnectionEditControlsEnabled(true); } - current_connection_edit_item->connection->map_name = mapName; - setCurrentConnectionDirection(direction); + setConnectionEditControlsEnabled(true); + selected_connection_item->connection->map_name = mapName; + setCurrentConnectionDirection(selected_connection_item->connection->direction); } void Editor::addNewConnection() { @@ -568,14 +570,14 @@ void Editor::addNewConnection() { } void Editor::removeCurrentConnection() { - if (!current_connection_edit_item) + if (!selected_connection_item) return; - map->connections.removeOne(current_connection_edit_item->connection); - connection_edit_items.removeOne(current_connection_edit_item); - scene->removeItem(current_connection_edit_item); - delete current_connection_edit_item; - current_connection_edit_item = NULL; + map->connections.removeOne(selected_connection_item->connection); + connection_edit_items.removeOne(selected_connection_item); + scene->removeItem(selected_connection_item); + delete selected_connection_item; + selected_connection_item = NULL; setConnectionEditControlsEnabled(false); ui->spinBox_ConnectionOffset->setValue(0); ui->label_NumConnections->setText(QString::number(map->connections.length())); diff --git a/editor.h b/editor.h index bf38920e..acb9a33e 100755 --- a/editor.h +++ b/editor.h @@ -50,7 +50,7 @@ public: void setCurrentConnectionDirection(QString curDirection); void setConnectionsVisibility(bool visible); void updateConnectionOffset(int offset); - void updateConnectionMap(QString mapName, QString direction); + void setConnectionMap(QString mapName); void addNewConnection(); void removeCurrentConnection(); void updateDiveMap(QString mapName); @@ -70,7 +70,7 @@ public: QGraphicsScene *scene = NULL; QGraphicsPixmapItem *current_view = NULL; MapPixmapItem *map_item = NULL; - ConnectionPixmapItem* current_connection_edit_item = NULL; + ConnectionPixmapItem* selected_connection_item = NULL; QList connection_edit_items; CollisionPixmapItem *collision_item = NULL; QGraphicsItemGroup *objects_group = NULL; diff --git a/mainwindow.cpp b/mainwindow.cpp index dbb6a037..f0da01ee 100755 --- a/mainwindow.cpp +++ b/mainwindow.cpp @@ -785,7 +785,7 @@ void MainWindow::on_spinBox_ConnectionOffset_valueChanged(int offset) void MainWindow::on_comboBox_ConnectedMap_currentTextChanged(const QString &mapName) { - editor->updateConnectionMap(mapName, ui->comboBox_ConnectionDirection->currentText().toLower()); + editor->setConnectionMap(mapName); } void MainWindow::on_pushButton_AddConnection_clicked() From 1a10eac29f39769f41eda7b1cb27d38e5e1782cc Mon Sep 17 00:00:00 2001 From: Marcus Huderle Date: Mon, 12 Mar 2018 20:51:27 -0700 Subject: [PATCH 17/20] Support 'mirror' connection editing. Can be toggled off via checkbox --- editor.cpp | 93 +++++++++++++++++++++++++++++++++++++++++++++++--- editor.h | 11 ++++-- mainwindow.cpp | 2 +- mainwindow.ui | 32 +++++++++++++++++ project.cpp | 4 +-- 5 files changed, 133 insertions(+), 9 deletions(-) diff --git a/editor.cpp b/editor.cpp index fdf869b4..448a7093 100755 --- a/editor.cpp +++ b/editor.cpp @@ -203,10 +203,25 @@ void Editor::setCurrentConnectionDirection(QString curDirection) { setConnectionEditControlValues(selected_connection_item->connection); } +void Editor::updateCurrentConnectionDirection(QString curDirection) { + if (!selected_connection_item) + return; + + QString originalDirection = selected_connection_item->connection->direction; + setCurrentConnectionDirection(curDirection); + updateMirroredConnectionDirection(selected_connection_item->connection, originalDirection); +} + +void Editor::onConnectionMoved(Connection* connection) { + updateMirroredConnectionOffset(connection); + onConnectionOffsetChanged(connection->offset.toInt()); +} + void Editor::onConnectionOffsetChanged(int newOffset) { ui->spinBox_ConnectionOffset->blockSignals(true); ui->spinBox_ConnectionOffset->setValue(newOffset); ui->spinBox_ConnectionOffset->blockSignals(false); + } void Editor::setConnectionEditControlValues(Connection* connection) { @@ -419,7 +434,6 @@ DraggablePixmapItem *Editor::addMapObject(Event *event) { void Editor::displayMapConnections() { for (QGraphicsPixmapItem* item : map->connection_items) { - scene->removeItem(item); delete item; } map->connection_items.clear(); @@ -474,7 +488,7 @@ void Editor::createConnectionItem(Connection* connection, bool hide) { connection_edit_item->setY(y); connection_edit_item->setZValue(-1); scene->addItem(connection_edit_item); - connect(connection_edit_item, SIGNAL(connectionMoved(int)), this, SLOT(onConnectionOffsetChanged(int))); + connect(connection_edit_item, SIGNAL(connectionMoved(Connection*)), this, SLOT(onConnectionMoved(Connection*))); connect(connection_edit_item, SIGNAL(connectionItemSelected(ConnectionPixmapItem*)), this, SLOT(onConnectionItemSelected(ConnectionPixmapItem*))); connect(connection_edit_item, SIGNAL(connectionItemDoubleClicked(ConnectionPixmapItem*)), this, SLOT(onConnectionItemDoubleClicked(ConnectionPixmapItem*))); connection_edit_items.append(connection_edit_item); @@ -524,6 +538,7 @@ void Editor::updateConnectionOffset(int offset) { selected_connection_item->setY(selected_connection_item->initialY + (offset - selected_connection_item->initialOffset) * 16); } selected_connection_item->blockSignals(false); + updateMirroredConnectionOffset(selected_connection_item->connection); } void Editor::setConnectionMap(QString mapName) { @@ -539,9 +554,11 @@ void Editor::setConnectionMap(QString mapName) { return; } + QString originalMapName = selected_connection_item->connection->map_name; setConnectionEditControlsEnabled(true); selected_connection_item->connection->map_name = mapName; setCurrentConnectionDirection(selected_connection_item->connection->direction); + updateMirroredConnectionMap(selected_connection_item->connection, originalMapName); } void Editor::addNewConnection() { @@ -559,14 +576,80 @@ void Editor::addNewConnection() { } } + // Don't connect the map to itself. + QString defaultMapName = project->mapNames->first(); + if (defaultMapName == map->name) { + defaultMapName = project->mapNames->value(1); + } + Connection* newConnection = new Connection; newConnection->direction = minDirection; newConnection->offset = "0"; - newConnection->map_name = project->mapNames->first(); + newConnection->map_name = defaultMapName; map->connections.append(newConnection); createConnectionItem(newConnection, true); onConnectionItemSelected(connection_edit_items.last()); ui->label_NumConnections->setText(QString::number(map->connections.length())); + + updateMirroredConnection(newConnection, newConnection->direction, newConnection->map_name); +} + +void Editor::updateMirroredConnectionOffset(Connection* connection) { + updateMirroredConnection(connection, connection->direction, connection->map_name); +} +void Editor::updateMirroredConnectionDirection(Connection* connection, QString originalDirection) { + updateMirroredConnection(connection, originalDirection, connection->map_name); +} +void Editor::updateMirroredConnectionMap(Connection* connection, QString originalMapName) { + updateMirroredConnection(connection, connection->direction, originalMapName); +} +void Editor::removeMirroredConnection(Connection* connection) { + updateMirroredConnection(connection, connection->direction, connection->map_name, true); +} +void Editor::updateMirroredConnection(Connection* connection, QString originalDirection, QString originalMapName, bool isDelete) { + if (!ui->checkBox_MirrorConnections->isChecked()) + return; + + static QMap oppositeDirections = QMap({ + {"up", "down"}, {"right", "left"}, {"down", "up"}, {"left", "right"}}); + QString oppositeDirection = oppositeDirections.value(originalDirection); + + // Find the matching connection in the connected map. + QMap *mapcache = project->map_cache; + Connection* mirrorConnection = NULL; + Map* otherMap = project->getMap(originalMapName); + for (Connection* conn : otherMap->connections) { + if (conn->direction == oppositeDirection && conn->map_name == map->name) { + mirrorConnection = conn; + } + } + + if (isDelete) { + if (mirrorConnection) { + otherMap->connections.removeOne(mirrorConnection); + delete mirrorConnection; + } + return; + } + + if (connection->direction != originalDirection || connection->map_name != originalMapName) { + if (mirrorConnection) { + otherMap->connections.removeOne(mirrorConnection); + delete mirrorConnection; + mirrorConnection = NULL; + otherMap = project->getMap(connection->map_name); + } + } + + // Create a new mirrored connection, if a matching one doesn't already exist. + if (!mirrorConnection) { + mirrorConnection = new Connection; + mirrorConnection->direction = oppositeDirections.value(connection->direction); + mirrorConnection->map_name = map->name; + otherMap->connections.append(mirrorConnection); + } + + mirrorConnection->offset = QString::number(-connection->offset.toInt()); } void Editor::removeCurrentConnection() { @@ -575,6 +658,8 @@ void Editor::removeCurrentConnection() { map->connections.removeOne(selected_connection_item->connection); connection_edit_items.removeOne(selected_connection_item); + removeMirroredConnection(selected_connection_item->connection); + scene->removeItem(selected_connection_item); delete selected_connection_item; selected_connection_item = NULL; @@ -751,8 +836,8 @@ QVariant ConnectionPixmapItem::itemChange(GraphicsItemChange change, const QVari y = initialY; } - emit connectionMoved(newOffset); connection->offset = QString::number(newOffset); + emit connectionMoved(connection); return QPointF(x, y); } else { diff --git a/editor.h b/editor.h index acb9a33e..07866b72 100755 --- a/editor.h +++ b/editor.h @@ -48,6 +48,7 @@ public: void setEditingObjects(); void setEditingConnections(); void setCurrentConnectionDirection(QString curDirection); + void updateCurrentConnectionDirection(QString curDirection); void setConnectionsVisibility(bool visible); void updateConnectionOffset(int offset); void setConnectionMap(QString mapName); @@ -101,11 +102,17 @@ private: void populateConnectionMapPickers(); void setDiveEmergeControls(); void updateDiveEmergeMap(QString mapName, QString direction); + void onConnectionOffsetChanged(int newOffset); + void removeMirroredConnection(Connection*); + void updateMirroredConnectionOffset(Connection*); + void updateMirroredConnectionDirection(Connection*, QString); + void updateMirroredConnectionMap(Connection*, QString); + void updateMirroredConnection(Connection*, QString, QString, bool isDelete = false); private slots: void mouseEvent_map(QGraphicsSceneMouseEvent *event, MapPixmapItem *item); void mouseEvent_collision(QGraphicsSceneMouseEvent *event, CollisionPixmapItem *item); - void onConnectionOffsetChanged(int newOffset); + void onConnectionMoved(Connection*); void onConnectionItemSelected(ConnectionPixmapItem* connectionItem); void onConnectionItemDoubleClicked(ConnectionPixmapItem* connectionItem); void onConnectionDirectionChanged(QString newDirection); @@ -310,7 +317,7 @@ protected: signals: void connectionItemSelected(ConnectionPixmapItem* connectionItem); void connectionItemDoubleClicked(ConnectionPixmapItem* connectionItem); - void connectionMoved(int offset); + void connectionMoved(Connection*); }; class MetatilesPixmapItem : public QObject, public QGraphicsPixmapItem { diff --git a/mainwindow.cpp b/mainwindow.cpp index f0da01ee..f1cfa90d 100755 --- a/mainwindow.cpp +++ b/mainwindow.cpp @@ -775,7 +775,7 @@ void MainWindow::on_action_Export_Map_Image_triggered() void MainWindow::on_comboBox_ConnectionDirection_currentIndexChanged(const QString &direction) { - editor->setCurrentConnectionDirection(direction); + editor->updateCurrentConnectionDirection(direction); } void MainWindow::on_spinBox_ConnectionOffset_valueChanged(int offset) diff --git a/mainwindow.ui b/mainwindow.ui index 57d6ad54..e6fa825c 100755 --- a/mainwindow.ui +++ b/mainwindow.ui @@ -1326,6 +1326,38 @@ + + + + Qt::Horizontal + + + QSizePolicy::Maximum + + + + 40 + 20 + + + + + + + + + 0 + 0 + + + + Mirror + + + true + + + diff --git a/project.cpp b/project.cpp index 29cbe6ae..cbf55183 100755 --- a/project.cpp +++ b/project.cpp @@ -39,7 +39,8 @@ Map* Project::loadMap(QString map_name) { Map *map; if (map_cache->contains(map_name)) { map = map_cache->value(map_name); - if (map->hasUnsavedChanges()) { + // TODO: uncomment when undo/redo history is fully implemented for all actions. + if (true/*map->hasUnsavedChanges()*/) { return map; } } else { @@ -1260,7 +1261,6 @@ void Project::loadObjectPixmaps(QList objects) { } if (event_type == "object") { - int sprite_id = constants.value(object->get("sprite")); QString info_label = pointers.value(sprite_id).replace("&", ""); From 9533042c4cfece1f826752291ea4383b1d3561a4 Mon Sep 17 00:00:00 2001 From: Marcus Huderle Date: Mon, 12 Mar 2018 21:52:58 -0700 Subject: [PATCH 18/20] Support 'mirror' editing for dive and emerge connections --- editor.cpp | 13 ++++++++++--- 1 file changed, 10 insertions(+), 3 deletions(-) diff --git a/editor.cpp b/editor.cpp index 448a7093..50af5d4e 100755 --- a/editor.cpp +++ b/editor.cpp @@ -611,7 +611,9 @@ void Editor::updateMirroredConnection(Connection* connection, QString originalDi return; static QMap oppositeDirections = QMap({ - {"up", "down"}, {"right", "left"}, {"down", "up"}, {"left", "right"}}); + {"up", "down"}, {"right", "left"}, + {"down", "up"}, {"left", "right"}, + {"dive", "emerge"},{"emerge", "dive"}}); QString oppositeDirection = oppositeDirections.value(originalDirection); // Find the matching connection in the connected map. @@ -698,16 +700,21 @@ void Editor::updateDiveEmergeMap(QString mapName, QString direction) { // Remove dive/emerge connection if (connection) { map->connections.removeOne(connection); + removeMirroredConnection(connection); } } else { if (!connection) { connection = new Connection; connection->direction = direction; connection->offset = "0"; + connection->map_name = mapName; map->connections.append(connection); + updateMirroredConnection(connection, connection->direction, connection->map_name); + } else { + QString originalMapName = connection->map_name; + connection->map_name = mapName; + updateMirroredConnectionMap(connection, originalMapName); } - - connection->map_name = mapName; } ui->label_NumConnections->setText(QString::number(map->connections.length())); From ae4158ce7b321c7b18cbee93a07358216196873a Mon Sep 17 00:00:00 2001 From: yenatch Date: Sun, 18 Mar 2018 21:28:52 -0400 Subject: [PATCH 19/20] Fix offset value when selecting another connection --- editor.cpp | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/editor.cpp b/editor.cpp index 50af5d4e..e4b69bb6 100755 --- a/editor.cpp +++ b/editor.cpp @@ -276,6 +276,7 @@ void Editor::onConnectionItemSelected(ConnectionPixmapItem* connectionItem) { setConnectionEditControlValues(selected_connection_item->connection); ui->spinBox_ConnectionOffset->setMaximum(selected_connection_item->getMaxOffset()); ui->spinBox_ConnectionOffset->setMinimum(selected_connection_item->getMinOffset()); + onConnectionOffsetChanged(selected_connection_item->connection->offset.toInt()); } void Editor::setSelectedConnectionFromMap(QString mapName) { @@ -534,7 +535,7 @@ void Editor::updateConnectionOffset(int offset) { selected_connection_item->connection->offset = QString::number(offset); if (selected_connection_item->connection->direction == "up" || selected_connection_item->connection->direction == "down") { selected_connection_item->setX(selected_connection_item->initialX + (offset - selected_connection_item->initialOffset) * 16); - } else { + } else if (selected_connection_item->connection->direction == "left" || selected_connection_item->connection->direction == "right") { selected_connection_item->setY(selected_connection_item->initialY + (offset - selected_connection_item->initialOffset) * 16); } selected_connection_item->blockSignals(false); From 7f74b3b481321203ba5bce7162d065b41793e27c Mon Sep 17 00:00:00 2001 From: yenatch Date: Sun, 18 Mar 2018 21:30:12 -0400 Subject: [PATCH 20/20] Need to include QMap in parseutil.h --- parseutil.h | 1 + 1 file changed, 1 insertion(+) diff --git a/parseutil.h b/parseutil.h index aec0bec4..dfd52c16 100755 --- a/parseutil.h +++ b/parseutil.h @@ -3,6 +3,7 @@ #include #include +#include enum TokenType { Number,