Update map view when tilesets change

editor.cpp

 }
 
 void Editor::setConnectionsVisibility(bool visible) {
-    for (QGraphicsPixmapItem* item : map->connection_items) {
+    for (QGraphicsPixmapItem* item : connection_items) {
         item->setVisible(visible);
         item->setActive(visible);
     }
 }
 
 void Editor::displayMap() {
-    scene = new QGraphicsScene;
+    if (!scene)
+        scene = new QGraphicsScene;
 
+    if (map_item && scene) {
+        scene->removeItem(map_item);
+        delete map_item;
+    }
     map_item = new MapPixmapItem(map);
     connect(map_item, SIGNAL(mouseEvent(QGraphicsSceneMouseEvent*,MapPixmapItem*)),
             this, SLOT(mouseEvent_map(QGraphicsSceneMouseEvent*,MapPixmapItem*)));
     map_item->draw(true);
     scene->addItem(map_item);
 
+    if (collision_item && scene) {
+        scene->removeItem(collision_item);
+        delete collision_item;
+    }
     collision_item = new CollisionPixmapItem(map);
     connect(collision_item, SIGNAL(mouseEvent(QGraphicsSceneMouseEvent*,CollisionPixmapItem*)),
             this, SLOT(mouseEvent_collision(QGraphicsSceneMouseEvent*,CollisionPixmapItem*)));
     collision_item->draw(true);
     scene->addItem(collision_item);
 
-    events_group = new EventGroup;
-    scene->addItem(events_group);
-
-    if (map_item) {
-        map_item->setVisible(false);
-    }
-    if (collision_item) {
-        collision_item->setVisible(false);
-    }
-    if (events_group) {
-        events_group->setVisible(false);
-    }
-
     int tw = 16;
     int th = 16;
     scene->setSceneRect(
     displayMapConnections();
     displayMapBorder();
     displayMapGrid();
+
+    if (map_item) {
+        map_item->setVisible(false);
+    }
+    if (collision_item) {
+        collision_item->setVisible(false);
+    }
+    if (events_group) {
+        events_group->setVisible(false);
+    }
 }
 
 void Editor::displayMetatiles() {
+    if (metatiles_item && metatiles_item->scene()) {
+        metatiles_item->scene()->removeItem(metatiles_item);
+        delete metatiles_item;
+    }
+
     scene_metatiles = new QGraphicsScene;
     metatiles_item = new MetatilesPixmapItem(map);
     metatiles_item->draw();
 }
 
 void Editor::displayBorderMetatiles() {
+    if (selected_border_metatiles_item && selected_border_metatiles_item->scene()) {
+        selected_border_metatiles_item->scene()->removeItem(selected_border_metatiles_item);
+        delete selected_border_metatiles_item;
+    }
+
     scene_selected_border_metatiles = new QGraphicsScene;
     selected_border_metatiles_item = new BorderMetatilesPixmapItem(map);
     selected_border_metatiles_item->draw();
 }
 
 void Editor::displayCollisionMetatiles() {
+    if (collision_metatiles_item && collision_metatiles_item->scene()) {
+        collision_metatiles_item->scene()->removeItem(collision_metatiles_item);
+        delete collision_metatiles_item;
+    }
+
     scene_collision_metatiles = new QGraphicsScene;
     collision_metatiles_item = new CollisionMetatilesPixmapItem(map);
     collision_metatiles_item->draw();
 }
 
 void Editor::displayElevationMetatiles() {
+    if (elevation_metatiles_item && elevation_metatiles_item->scene()) {
+        elevation_metatiles_item->scene()->removeItem(elevation_metatiles_item);
+        delete elevation_metatiles_item;
+    }
+
     scene_elevation_metatiles = new QGraphicsScene;
     elevation_metatiles_item = new ElevationMetatilesPixmapItem(map);
     elevation_metatiles_item->draw();
 }
 
 void Editor::displayMapEvents() {
-    for (QGraphicsItem *child : events_group->childItems()) {
-        events_group->removeFromGroup(child);
+    if (events_group) {
+        for (QGraphicsItem *child : events_group->childItems()) {
+            events_group->removeFromGroup(child);
+            delete child;
+        }
+
+        if (events_group->scene()) {
+            events_group->scene()->removeItem(events_group);
+        }
+
+        delete events_group;
     }
 
+    events_group = new EventGroup;
+    scene->addItem(events_group);
+
     QList<Event *> events = map->getAllEvents();
     project->loadEventPixmaps(events);
     for (Event *event : events) {
 }
 
 void Editor::displayMapConnections() {
-    for (QGraphicsPixmapItem* item : map->connection_items) {
+    for (QGraphicsPixmapItem* item : connection_items) {
+        if (item->scene()) {
+            item->scene()->removeItem(item);
+        }
         delete item;
     }
-    map->connection_items.clear();
+    connection_items.clear();
 
     for (ConnectionPixmapItem* item : connection_edit_items) {
+        if (item->scene()) {
+            item->scene()->removeItem(item);
+        }
         delete item;
     }
     selected_connection_item = NULL;
     item->setX(x);
     item->setY(y);
     scene->addItem(item);
-    map->connection_items.append(item);
+    connection_items.append(item);
     item->setVisible(!hide);
 
     ConnectionPixmapItem *connection_edit_item = new ConnectionPixmapItem(pixmap, connection, x, y, map->getWidth(), map->getHeight());
 }
 
 void Editor::displayMapBorder() {
+    for (QGraphicsPixmapItem* item : borderItems) {
+        if (item->scene()) {
+            item->scene()->removeItem(item);
+        }
+        delete item;
+    }
+    borderItems.clear();
+
     QPixmap pixmap = map->renderBorder();
     for (int y = -6; y < map->getHeight() + 6; y += 2)
     for (int x = -6; x < map->getWidth() + 6; x += 2) {
 }
 
 void Editor::displayMapGrid() {
+    for (QGraphicsLineItem* item : gridLines) {
+        if (item && item->scene()) {
+            item->scene()->removeItem(item);
+        }
+        delete item;
+    }
+    gridLines.clear();
+    ui->checkBox_ToggleGrid->disconnect();
+
     int pixelWidth = map->getWidth() * 16;
     int pixelHeight = map->getHeight() * 16;
     for (int i = 0; i <= map->getWidth(); i++) {
         int x = i * 16;
         QGraphicsLineItem *line = scene->addLine(x, 0, x, pixelHeight);
         line->setVisible(ui->checkBox_ToggleGrid->isChecked());
+        gridLines.append(line);
         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(ui->checkBox_ToggleGrid->isChecked());
+        gridLines.append(line);
         connect(ui->checkBox_ToggleGrid, &QCheckBox::toggled, [=](bool checked){line->setVisible(checked);});
     }
 }
     connection_edit_items.removeOne(selected_connection_item);
     removeMirroredConnection(selected_connection_item->connection);
 
-    scene->removeItem(selected_connection_item);
-    delete selected_connection_item;
+    if (selected_connection_item && selected_connection_item->scene()) {
+        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()));
 }
 
+void Editor::updatePrimaryTileset(QString tilesetLabel)
+{
+    map->layout->tileset_primary_label = tilesetLabel;
+    map->layout->tileset_primary = project->getTileset(tilesetLabel);
+    emit tilesetChanged(map->name);
+}
+
+void Editor::updateSecondaryTileset(QString tilesetLabel)
+{
+    map->layout->tileset_secondary_label = tilesetLabel;
+    map->layout->tileset_secondary = project->getTileset(tilesetLabel);
+    emit tilesetChanged(map->name);
+}
+
 void MetatilesPixmapItem::paintTileChanged(Map *map) {
     draw();
 }

editor.h

     void updateDiveMap(QString mapName);
     void updateEmergeMap(QString mapName);
     void setSelectedConnectionFromMap(QString mapName);
+    void updatePrimaryTileset(QString tilesetLabel);
+    void updateSecondaryTileset(QString tilesetLabel);
 
     DraggablePixmapItem *addMapEvent(Event *event);
     void selectMapEvent(DraggablePixmapItem *object);
     QGraphicsPixmapItem *current_view = NULL;
     MapPixmapItem *map_item = NULL;
     ConnectionPixmapItem* selected_connection_item = NULL;
+    QList<QGraphicsPixmapItem*> connection_items;
     QList<ConnectionPixmapItem*> connection_edit_items;
     CollisionPixmapItem *collision_item = NULL;
     QGraphicsItemGroup *events_group = NULL;
     QList<QGraphicsPixmapItem*> borderItems;
+    QList<QGraphicsLineItem*> gridLines;
 
     QGraphicsScene *scene_metatiles = NULL;
     QGraphicsScene *scene_selected_border_metatiles = NULL;
     void objectsChanged();
     void selectedObjectsChanged();
     void loadMapRequested(QString, QString);
+    void tilesetChanged(QString);
 };
 
 

mainwindow.cpp

     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)));
+    connect(editor, SIGNAL(tilesetChanged(QString)), this, SLOT(onTilesetChanged(QString)));
 
     on_toolButton_Paint_clicked();
 
     ui->comboBox_Weather->clear();
     ui->comboBox_Type->clear();
     ui->comboBox_BattleScene->clear();
+    ui->comboBox_PrimaryTileset->clear();
+    ui->comboBox_SecondaryTileset->clear();
     ui->checkBox_ShowLocation->setChecked(false);
     if (!editor || !editor->map || !editor->project) {
         ui->frame_3->setEnabled(false);
     setMap(newMapName);
 }
 
+void MainWindow::onTilesetChanged(QString mapName)
+{
+    setMap(mapName);
+}
+
 void MainWindow::on_mapList_activated(const QModelIndex &index)
 {
     QVariant data = index.data(Qt::UserRole);
 {
     editor->updateEmergeMap(mapName);
 }
+
+void MainWindow::on_comboBox_PrimaryTileset_activated(const QString &tilesetLabel)
+{
+    editor->updatePrimaryTileset(tilesetLabel);
+}
+
+void MainWindow::on_comboBox_SecondaryTileset_activated(const QString &tilesetLabel)
+{
+    editor->updateSecondaryTileset(tilesetLabel);
+}

mainwindow.h

 
     void onOpenMapListContextMenu(const QPoint &point);
     void onAddNewMapToGroupClick(QAction* triggeredAction);
+    void onTilesetChanged(QString);
 
     void on_action_Export_Map_Image_triggered();
 
 
     void on_comboBox_EmergeMap_currentTextChanged(const QString &mapName);
 
+    void on_comboBox_PrimaryTileset_activated(const QString &arg1);
+
+    void on_comboBox_SecondaryTileset_activated(const QString &arg1);
+
 private:
     Ui::MainWindow *ui;
     QStandardItemModel *mapListModel;

map.h

     QMap<QString, QList<Event*>> events;
 
     QList<Connection*> connections;
-    QList<QGraphicsPixmapItem*> connection_items;
     QPixmap renderConnection(Connection);
 
     QPixmap renderBorder();

project.cpp

     }
 
     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);
         map->layout = mapLayouts[map->layout_label];
     }
 
-    getMapTilesets(map);
+    loadMapTilesets(map);
     loadBlockdata(map);
     loadMapBorder(map);
 }
     saveTextFile(root + "/include/constants/maps.h", text);
 }
 
-void Project::getMapTilesets(Map* map) {
+void Project::loadMapTilesets(Map* map) {
     if (map->layout->has_unsaved_changes) {
         return;
     }
     mapNamesToMapConstants->insert(map->name, map->constantName);
     setNewMapHeader(map, mapLayoutsTable.size() + 1);
     setNewMapLayout(map);
-    getMapTilesets(map);
+    loadMapTilesets(map);
     setNewMapBlockdata(map);
     setNewMapBorder(map);
     setNewMapEvents(map);

project.h

     QStringList* readLayoutValues(QString layoutName);
     void readMapLayout(Map*);
     void readMapsWithConnections();
-    void getMapTilesets(Map*);
+    void loadMapTilesets(Map*);
     void loadTilesetAssets(Tileset*);
 
     void saveBlockdata(Map*);

tileset.cpp

 
 #include <QPainter>
 #include <QImage>
+#include <QDebug>
 
 Tileset::Tileset()
 {
         }
 
         // Colorize the metatile tiles with its palette.
-        QList<QRgb> palette = palettes.value(tile_.palette);
-        for (int j = 0; j < palette.length(); j++) {
-            tile_image.setColor(j, palette.value(j));
+        if (tile_.palette < palettes.length()) {
+            QList<QRgb> palette = palettes.value(tile_.palette);
+            for (int j = 0; j < palette.length(); j++) {
+                tile_image.setColor(j, palette.value(j));
+            }
+        } else {
+            qDebug() << "Tile is referring to invalid palette number: " << tile_.palette;
         }
 
         // The top layer of the metatile has its last color displayed at transparent.
     for (int i = 0; i < 6; i++) {
         palettes.append(primaryTileset->palettes->at(i));
     }
-    for (int i = 6; i < secondaryTileset->palettes->length(); i++) {
+    for (int i = 6; i < 12; i++) {
         palettes.append(secondaryTileset->palettes->at(i));
     }
     return palettes;