Merge pull request #20 from huderlem/maps

Support adding new maps

asm.cpp

         //QString macro;
         //QStringList *params;
         strip_comment(&line);
-        if (line.isEmpty()) {
+        if (line.trimmed().isEmpty()) {
         } else if (line.contains(':')) {
             label = line.left(line.indexOf(':'));
             QStringList *list = new QStringList;

editor.cpp

 void Editor::saveProject() {
     if (project) {
         project->saveAllMaps();
+        project->saveAllDataStructures();
     }
 }
 
 void Editor::save() {
     if (project && map) {
         project->saveMap(map);
+        project->saveAllDataStructures();
     }
 }
 

main.cpp

 int main(int argc, char *argv[])
 {
     QApplication a(argc, argv);
+    a.setStyle("fusion");
     MainWindow w;
     w.show();
 

mainwindow.cpp

         editor->project = new Project;
         editor->project->root = dir;
         setWindowTitle(editor->project->getProjectTitle() + " - pretmap");
+        loadDataStructures();
         populateMapList();
         setMap(getDefaultMap());
     } else {
         setWindowTitle(editor->project->getProjectTitle() + " - pretmap");
+        loadDataStructures();
         populateMapList();
     }
 }
 
 QString MainWindow::getDefaultMap() {
     if (editor && editor->project) {
-        QList<QStringList*> *names = editor->project->groupedMapNames;
-        if (names) {
+        QList<QStringList> names = editor->project->groupedMapNames;
+        if (!names.isEmpty()) {
             QSettings settings;
             QString key = "project:" + editor->project->root;
             if (settings.contains(key)) {
                 QMap<QString, QVariant> qmap = settings.value(key).toMap();
                 if (qmap.contains("recent_map")) {
                     QString map_name = qmap.value("recent_map").toString();
-                    for (int i = 0; i < names->length(); i++) {
-                        if (names->value(i)->contains(map_name)) {
+                    for (int i = 0; i < names.length(); i++) {
+                        if (names.value(i).contains(map_name)) {
                             return map_name;
                         }
                     }
                 }
             }
             // Failing that, just get the first map in the list.
-            for (int i = 0; i < names->length(); i++) {
-                QStringList *list = names->value(i);
-                if (list->length()) {
-                    return list->value(0);
+            for (int i = 0; i < names.length(); i++) {
+                QStringList list = names.value(i);
+                if (list.length()) {
+                    return list.value(0);
                 }
             }
         }
     }
 }
 
+void MainWindow::loadDataStructures() {
+    Project *project = editor->project;
+    project->readMapAttributesTable();
+    project->readAllMapAttributes();
+}
 
 void MainWindow::populateMapList() {
     Project *project = editor->project;
     QIcon folderIcon;
     folderIcon.addFile(QStringLiteral(":/icons/folder_closed.ico"), QSize(), QIcon::Normal, QIcon::Off);
 
-    QIcon mapIcon;
-    mapIcon.addFile(QStringLiteral(":/icons/map.ico"), QSize(), QIcon::Normal, QIcon::Off);
-    mapIcon.addFile(QStringLiteral(":/icons/image.ico"), QSize(), QIcon::Normal, QIcon::On);
+    mapIcon = new QIcon;
+    mapIcon->addFile(QStringLiteral(":/icons/map.ico"), QSize(), QIcon::Normal, QIcon::Off);
+    mapIcon->addFile(QStringLiteral(":/icons/image.ico"), QSize(), QIcon::Normal, QIcon::On);
 
-    QStandardItemModel *model = new QStandardItemModel;
+    mapListModel = new QStandardItemModel;
+    mapGroupsModel = new QList<QStandardItem*>;
 
     QStandardItem *entry = new QStandardItem;
     entry->setText(project->getProjectTitle());
     entry->setIcon(folderIcon);
     entry->setEditable(false);
-    model->appendRow(entry);
+    mapListModel->appendRow(entry);
 
     QStandardItem *maps = new QStandardItem;
     maps->setText("maps");
         group->setText(group_name);
         group->setIcon(mapFolderIcon);
         group->setEditable(false);
+        group->setData(group_name, Qt::UserRole);
+        group->setData("map_group", MapListUserRoles::TypeRole);
+        group->setData(i, MapListUserRoles::GroupRole);
         maps->appendRow(group);
-        QStringList *names = project->groupedMapNames->value(i);
-        for (int j = 0; j < names->length(); j++) {
-            QString map_name = names->value(j);
-            QStandardItem *map = new QStandardItem;
-            map->setText(QString("[%1.%2] ").arg(i).arg(j, 2, 10, QLatin1Char('0')) + map_name);
-            map->setIcon(mapIcon);
-            map->setEditable(false);
-            map->setData(map_name, Qt::UserRole);
+        mapGroupsModel->append(group);
+        QStringList names = project->groupedMapNames.value(i);
+        for (int j = 0; j < names.length(); j++) {
+            QString map_name = names.value(j);
+            QStandardItem *map = createMapItem(map_name, i, j);
             group->appendRow(map);
-            //ui->mapList->setExpanded(model->indexFromItem(map), false); // redundant
         }
     }
 
-    ui->mapList->setModel(model);
+    // Right-clicking on items in the map list tree view brings up a context menu.
+    ui->mapList->setContextMenuPolicy(Qt::CustomContextMenu);
+    connect(ui->mapList, SIGNAL(customContextMenuRequested(const QPoint &)),
+            this, SLOT(onOpenMapListContextMenu(const QPoint &)));
+
+    ui->mapList->setModel(mapListModel);
     ui->mapList->setUpdatesEnabled(true);
     ui->mapList->expandToDepth(2);
     ui->mapList->repaint();
 }
 
+QStandardItem* MainWindow::createMapItem(QString mapName, int groupNum, int inGroupNum) {
+    QStandardItem *map = new QStandardItem;
+    map->setText(QString("[%1.%2] ").arg(groupNum).arg(inGroupNum, 2, 10, QLatin1Char('0')) + mapName);
+    map->setIcon(*mapIcon);
+    map->setEditable(false);
+    map->setData(mapName, Qt::UserRole);
+    map->setData("map_name", MapListUserRoles::TypeRole);
+    return map;
+}
+
+void MainWindow::onOpenMapListContextMenu(const QPoint &point)
+{
+    QModelIndex index = ui->mapList->indexAt(point);
+    if (!index.isValid()) {
+        return;
+    }
+
+    QStandardItem *selectedItem = mapListModel->itemFromIndex(index);
+    QVariant itemType = selectedItem->data(MapListUserRoles::TypeRole);
+    if (!itemType.isValid()) {
+        return;
+    }
+
+    // Build custom context menu depending on which type of item was selected (map group, map name, etc.)
+    if (itemType == "map_group") {
+        QString groupName = selectedItem->data(Qt::UserRole).toString();
+        int groupNum = selectedItem->data(MapListUserRoles::GroupRole).toInt();
+        QMenu* menu = new QMenu();
+        QActionGroup* actions = new QActionGroup(menu);
+        actions->addAction(menu->addAction("Add New Map to Group"))->setData(groupNum);
+        connect(actions, SIGNAL(triggered(QAction*)), this, SLOT(onAddNewMapToGroupClick(QAction*)));
+        menu->exec(QCursor::pos());
+    }
+}
+
+void MainWindow::onAddNewMapToGroupClick(QAction* triggeredAction)
+{
+    int groupNum = triggeredAction->data().toInt();
+    QStandardItem* groupItem = mapGroupsModel->at(groupNum);
+
+    QString newMapName = editor->project->getNewMapName();
+    Map* newMap = editor->project->addNewMapToGroup(newMapName, groupNum);
+    editor->project->saveMap(newMap);
+    editor->project->saveAllDataStructures();
+
+    int numMapsInGroup = groupItem->rowCount();
+    QStandardItem *newMapItem = createMapItem(newMapName, groupNum, numMapsInGroup);
+    groupItem->appendRow(newMapItem);
+
+    setMap(newMapName);
+}
+
 void MainWindow::on_mapList_activated(const QModelIndex &index)
 {
     QVariant data = index.data(Qt::UserRole);

mainwindow.h

 #include <QString>
 #include <QModelIndex>
 #include <QMainWindow>
+#include <QStandardItemModel>
 #include <QGraphicsPixmapItem>
 #include <QGraphicsItemGroup>
 #include <QGraphicsSceneMouseEvent>
 
     void on_toolButton_Dropper_clicked();
 
+    void onOpenMapListContextMenu(const QPoint &point);
+    void onAddNewMapToGroupClick(QAction* triggeredAction);
+
 private:
     Ui::MainWindow *ui;
+    QStandardItemModel *mapListModel;
+    QList<QStandardItem*> *mapGroupsModel;
     Editor *editor = NULL;
+    QIcon* mapIcon;
     void setMap(QString);
+    void loadDataStructures();
     void populateMapList();
     QString getExistingDirectory(QString);
     void openProject(QString dir);
     QString getDefaultMap();
     void setRecentMap(QString map_name);
+    QStandardItem* createMapItem(QString mapName, int groupNum, int inGroupNum);
 
     void markAllEdited(QAbstractItemModel *model);
     void markEdited(QModelIndex index);
     void checkToolButtons();
 };
 
+enum MapListUserRoles {
+    GroupRole = Qt::UserRole + 1, // Used to hold the map group number.
+    TypeRole = Qt::UserRole + 2,  // Used to differentiate between the different layers of the map list tree view.
+};
+
 #endif // MAINWINDOW_H

map.cpp

 }
 
 bool Map::hasUnsavedChanges() {
-    return !history.isSaved();
+    return !history.isSaved() || !isPersistedToFile;
 }

map.h

 public:
     QString name;
     QString constantName;
+    QString group_num;
     QString attributes_label;
     QString events_label;
     QString scripts_label;
 
     Blockdata* blockdata = NULL;
 
+    bool isPersistedToFile = true;
+
 public:
     void setName(QString mapName);
     static QString mapConstantFromName(QString mapName);

project.cpp

 #include "event.h"
 
 #include <QDebug>
+#include <QDir>
 #include <QFile>
 #include <QTextStream>
+#include <QStandardItem>
 #include <QMessageBox>
 #include <QRegularExpression>
 
 Project::Project()
 {
     groupNames = new QStringList;
-    groupedMapNames = new QList<QStringList*>;
+    map_groups = new QMap<QString, int>;
     mapNames = new QStringList;
     map_cache = new QMap<QString, Map*>;
+    mapConstantsToMapNames = new QMap<QString, QString>;
+    mapNamesToMapConstants = new QMap<QString, QString>;
     tileset_cache = new QMap<QString, Tileset*>;
 }
 
 }
 
 Map* Project::loadMap(QString map_name) {
-    Map *map = new Map;
+    Map *map;
+    if (map_cache->contains(map_name)) {
+        map = map_cache->value(map_name);
+        if (map->hasUnsavedChanges()) {
+            return map;
+        }
+    } else {
+        map = new Map;
+        map->setName(map_name);
+    }
 
-    map->setName(map_name);
     readMapHeader(map);
     readMapAttributes(map);
     getTilesets(map);
 }
 
 void Project::loadMapConnections(Map *map) {
+    if (!map->isPersistedToFile) {
+        return;
+    }
+
     map->connections.clear();
     if (!map->connections_label.isNull()) {
         QString path = root + QString("/data/maps/%1/connections.inc").arg(map->name);
                     connection->direction = command.value(1);
                     connection->offset = command.value(2);
                     QString mapConstant = command.value(3);
-                    if (mapConstantsToMapNames.contains(mapConstant)) {
-                        connection->map_name = mapConstantsToMapNames[mapConstant];
+                    if (mapConstantsToMapNames->contains(mapConstant)) {
+                        connection->map_name = mapConstantsToMapNames->value(mapConstant);
                         map->connections.append(connection);
                     } else {
                         qDebug() << QString("Failed to find connected map for map constant '%1'").arg(mapConstant);
     }
 }
 
+void Project::setNewMapConnections(Map *map) {
+    map->connections.clear();
+}
+
 QList<QStringList>* Project::getLabelMacros(QList<QStringList> *list, QString label) {
     bool in_label = false;
     QList<QStringList> *new_list = new QList<QStringList>;
 }
 
 void Project::readMapHeader(Map* map) {
+    if (!map->isPersistedToFile) {
+        return;
+    }
+
     QString label = map->name;
     Asm *parser = new Asm;
 
     map->battle_scene = header->value(12);
 }
 
+void Project::setNewMapHeader(Map* map, int mapIndex) {
+    map->attributes_label = QString("%1_MapAttributes").arg(map->name);
+    map->events_label = QString("%1_MapEvents").arg(map->name);;
+    map->scripts_label = QString("%1_MapScripts").arg(map->name);;
+    map->connections_label = "0x0";
+    map->song = "BGM_DAN02";
+    map->index = QString("%1").arg(mapIndex);
+    map->location = "0";
+    map->visibility = "0";
+    map->weather = "2";
+    map->type = "1";
+    map->unknown = "0";
+    map->show_location = "1";
+    map->battle_scene = "0";
+}
+
 void Project::saveMapHeader(Map *map) {
     QString label = map->name;
     QString header_path = root + "/data/maps/" + label + "/header.inc";
     saveTextFile(header_path, text);
 }
 
+void Project::readMapAttributesTable() {
+    int curMapIndex = 1;
+    QString attributesText = readTextFile(getMapAttributesTableFilepath());
+    QList<QStringList>* values = parse(attributesText);
+    bool inAttributePointers = false;
+    for (int i = 0; i < values->length(); i++) {
+        QStringList params = values->value(i);
+        QString macro = params.value(0);
+        if (macro == ".label") {
+            if (inAttributePointers) {
+                break;
+            }
+            if (params.value(1) == "gMapAttributes") {
+                inAttributePointers = true;
+            }
+        } else if (macro == ".4byte" && inAttributePointers) {
+            QString mapName = params.value(1);
+            if (!mapName.contains("UnknownMapAttributes")) {
+                // Strip off "_MapAttributes" from the label if it's a real map label.
+                mapName = mapName.remove(mapName.length() - 14, 14);
+            }
+            mapAttributesTable.insert(curMapIndex, mapName);
+            curMapIndex++;
+        }
+    }
+
+    // Deep copy
+    mapAttributesTableMaster = mapAttributesTable;
+    mapAttributesTableMaster.detach();
+}
+
+void Project::saveMapAttributesTable() {
+    QString text = "";
+    text += QString("\t.align 2\n");
+    text += QString("gMapAttributes::\n");
+    for (int i = 0; i < mapAttributesTableMaster.count(); i++) {
+        int mapIndex = i + 1;
+        QString mapName = mapAttributesTableMaster.value(mapIndex);
+        if (!mapName.contains("UnknownMapAttributes")) {
+            text += QString("\t.4byte %1_MapAttributes\n").arg(mapName);
+        } else {
+            text += QString("\t.4byte %1\n").arg(mapName);
+        }
+    }
+    saveTextFile(getMapAttributesTableFilepath(), text);
+}
+
+QString Project::getMapAttributesTableFilepath() {
+    return QString("%1/data/maps/attributes_table.inc").arg(root);
+}
+
 void Project::readMapAttributes(Map* map) {
+    if (!map->isPersistedToFile) {
+        return;
+    }
+
     Asm *parser = new Asm;
 
-    QString assets_text = readTextFile(root + "/data/maps/_assets.inc");
+    QString assets_text = readTextFile(getMapAssetsFilepath());
     if (assets_text.isNull()) {
         return;
     }
     map->tileset_secondary_label = attributes->value(5);
 }
 
+void Project::readAllMapAttributes() {
+    mapAttributes.clear();
+
+    Asm *parser = new Asm;
+    QString assets_text = readTextFile(getMapAssetsFilepath());
+    if (assets_text.isNull()) {
+        return;
+    }
+
+    QList<QStringList> *commands = parser->parse(assets_text);
+
+    // Assume the _assets.inc file is grouped consistently in the order of:
+    // 1. <map_name>_MapBorder
+    // 2. <map_name>_MapBlockdata
+    // 3. <map_name>_MapAttributes
+    int i = 0;
+    while (i < commands->length()) {
+        // Read MapBorder assets.
+        QStringList borderParams = commands->value(i++);
+        bool isUnknownMapBorder = borderParams.value(1).startsWith("UnknownMapBorder_");
+        if (borderParams.value(0) != ".label" || (!borderParams.value(1).endsWith("_MapBorder") && !isUnknownMapBorder)) {
+            qDebug() << QString("Expected MapBorder label, but found %1").arg(borderParams.value(1));
+            continue;
+        }
+        QString borderLabel = borderParams.value(1);
+        QString mapName;
+        if (!isUnknownMapBorder) {
+            mapName = borderLabel.remove(borderLabel.length() - 10, 10);
+        } else {
+            // Unknown map name has to match the MapAttributes label.
+            mapName = borderLabel.replace("Border", "Attributes");
+        }
+
+        mapAttributes[mapName].insert("border_label", borderParams.value(1));
+        borderParams = commands->value(i++);
+        mapAttributes[mapName].insert("border_filepath", borderParams.value(1).replace("\"", ""));
+
+        // Read MapBlockData assets.
+        QStringList blockDataParams = commands->value(i++);
+        bool isUnknownMapBlockdata = blockDataParams.value(1).startsWith("UnknownMapBlockdata_");
+        if (blockDataParams.value(0) != ".label" || (!blockDataParams.value(1).endsWith("_MapBlockdata") && !isUnknownMapBlockdata)) {
+            qDebug() << QString("Expected MapBlockdata label, but found %1").arg(blockDataParams.value(1));
+            continue;
+        }
+        QString blockDataLabel = blockDataParams.value(1);
+        mapAttributes[mapName].insert("blockdata_label", blockDataLabel);
+        blockDataParams = commands->value(i++);
+        mapAttributes[mapName].insert("blockdata_filepath", blockDataParams.value(1).replace("\"", ""));
+
+        // Read MapAttributes assets.
+        i++; // skip .align
+        // Maps can share MapAttributes, so  gather a list of them.
+        QStringList attributeMapLabels;
+        QStringList attributesParams;
+        QStringList* sharedAttrMaps = new QStringList;
+        while (i < commands->length()) {
+            attributesParams = commands->value(i);
+            if (attributesParams.value(0) != ".label") {
+                break;
+            }
+            QString attrLabel = attributesParams.value(1);
+            attributeMapLabels.append(attrLabel);
+            sharedAttrMaps->append(attrLabel);
+            i++;
+        }
+
+        // Apply the map attributes to each of the shared maps.
+        QString attrWidth = commands->value(i++).value(1);
+        QString attrHeight = commands->value(i++).value(1);
+        QString attrBorderLabel = commands->value(i++).value(1);
+        QString attrBlockdataLabel = commands->value(i++).value(1);
+        QString attrTilesetPrimary = commands->value(i++).value(1);
+        QString attrTilesetSecondary = commands->value(i++).value(1);
+        for (QString attributeMapLabel: attributeMapLabels) {
+            QString altMapName = attributeMapLabel;
+            if (!altMapName.startsWith("UnknownMapAttributes_")) {
+                altMapName.remove(altMapName.length() - 14, 14);
+            }
+            if (!mapAttributes.contains(altMapName)) {
+                mapAttributes.insert(altMapName, QMap<QString, QString>());
+            }
+            mapAttributes[altMapName].insert("attributes_label", attributeMapLabel);
+            mapAttributes[altMapName].insert("width", attrWidth);
+            mapAttributes[altMapName].insert("height", attrHeight);
+            mapAttributes[altMapName].insert("border_label", attrBorderLabel);
+            mapAttributes[altMapName].insert("blockdata_label", attrBlockdataLabel);
+            mapAttributes[altMapName].insert("tileset_primary", attrTilesetPrimary);
+            mapAttributes[altMapName].insert("tileset_secondary", attrTilesetSecondary);
+
+            if (sharedAttrMaps->length() > 1) {
+                mapAttributes[altMapName].insert("shared_attr_maps", sharedAttrMaps->join(":"));
+            }
+        }
+    }
+
+    // Deep copy
+    mapAttributesMaster = mapAttributes;
+    mapAttributesMaster.detach();
+}
+
+void Project::saveAllMapAttributes() {
+    QString text = "";
+    for (int i = 0; i < mapAttributesTableMaster.count(); i++) {
+        int mapIndex = i + 1;
+        QString mapName = mapAttributesTableMaster.value(mapIndex);
+        QMap<QString, QString> attrs = mapAttributesMaster.value(mapName);
+
+        // Find the map attributes object that contains the border data.
+        QMap<QString, QString> attrsWithBorder;
+        if (attrs.contains("border_filepath")) {
+            attrsWithBorder = attrs;
+        } else {
+            QStringList labels = attrs.value("shared_attr_maps").split(":");
+            for (QString label : labels) {
+                label.remove(label.length() - 14, 14);
+                if (mapAttributesMaster.contains(label) && mapAttributesMaster.value(label).contains("border_filepath")) {
+                    attrsWithBorder = mapAttributesMaster.value(label);
+                    break;
+                }
+            }
+        }
+        if (!attrsWithBorder.isEmpty()) {
+            text += QString("%1::\n").arg(attrsWithBorder.value("border_label"));
+            text += QString("\t.incbin \"%1\"\n").arg(attrsWithBorder.value("border_filepath"));
+            text += QString("\n");
+        }
+
+        // Find the map attributes object that contains the blockdata.
+        QMap<QString, QString> attrsWithBlockdata;
+        if (attrs.contains("blockdata_filepath")) {
+            attrsWithBlockdata = attrs;
+        } else {
+            QStringList labels = attrs["shared_attr_maps"].split(":");
+            for (QString label : labels) {
+                label.remove(label.length() - 14, 14);
+                if (mapAttributesMaster.contains(label) && mapAttributesMaster.value(label).contains("blockdata_filepath")) {
+                    attrsWithBlockdata = mapAttributesMaster.value(label);
+                    break;
+                }
+            }
+        }
+        if (!attrsWithBlockdata.isEmpty()) {
+            text += QString("%1::\n").arg(attrsWithBlockdata.value("blockdata_label"));
+            text += QString("\t.incbin \"%1\"\n").arg(attrsWithBorder.value("blockdata_filepath"));
+            text += QString("\n");
+        }
+
+        text += QString("\t.align 2\n");
+        if (attrs.contains("shared_attr_maps")) {
+            QStringList labels = attrs.value("shared_attr_maps").split(":");
+            for (QString label : labels) {
+                text += QString("%1::\n").arg(label);
+            }
+        } else {
+            text += QString("%1::\n").arg(attrs.value("attributes_label"));
+        }
+        text += QString("\t.4byte %1\n").arg(attrs.value("width"));
+        text += QString("\t.4byte %1\n").arg(attrs.value("height"));
+        text += QString("\t.4byte %1\n").arg(attrs.value("border_label"));
+        text += QString("\t.4byte %1\n").arg(attrs.value("blockdata_label"));
+        text += QString("\t.4byte %1\n").arg(attrs.value("tileset_primary"));
+        text += QString("\t.4byte %1\n").arg(attrs.value("tileset_secondary"));
+        text += QString("\n");
+    }
+
+    saveTextFile(getMapAssetsFilepath(), text);
+}
+
+QString Project::getMapAssetsFilepath() {
+    return root + "/data/maps/_assets.inc";
+}
+
+void Project::setNewMapAttributes(Map* map) {
+    map->width = "20";
+    map->height = "20";
+    map->border_label = QString("%1_MapBorder").arg(map->name);
+    map->blockdata_label = QString("%1_MapBlockdata").arg(map->name);
+    map->tileset_primary_label = "gTileset_General";
+    map->tileset_secondary_label = "gTileset_Petalburg";
+
+    // Insert new entry into the global map attributes.
+    QMap<QString, QString> attrs;
+    attrs.insert("border_label", QString("%1_MapBorder").arg(map->name));
+    attrs.insert("border_filepath", QString("data/maps/%1/border.bin").arg(map->name));
+    attrs.insert("blockdata_label", QString("%1_MapBlockdata").arg(map->name));
+    attrs.insert("blockdata_filepath", QString("data/maps/%1/map.bin").arg(map->name));
+    attrs.insert("attributes_label", QString("%1_MapAttributes").arg(map->name));
+    attrs.insert("width", map->width);
+    attrs.insert("height", map->height);
+    attrs.insert("tileset_primary", map->tileset_primary_label);
+    attrs.insert("tileset_secondary", map->tileset_secondary_label);
+    mapAttributes.insert(map->name, attrs);
+}
+
+void Project::saveMapGroupsTable() {
+    QString text = "";
+    int groupNum = 0;
+    for (QStringList mapNames : groupedMapNames) {
+        text += QString("\t.align 2\n");
+        text += QString("gMapGroup%1::\n").arg(groupNum);
+        for (QString mapName : mapNames) {
+            text += QString("\t.4byte %1\n").arg(mapName);
+        }
+        text += QString("\n");
+        groupNum++;
+    }
+
+    text += QString("\t.align 2\n");
+    text += QString("gMapGroups::\n");
+    for (int i = 0; i < groupNum; i++) {
+        text += QString("\t.4byte gMapGroup%1\n").arg(i);
+    }
+
+    saveTextFile(root + "/data/maps/_groups.inc", text);
+}
+
+void Project::saveMapConstantsHeader() {
+    QString text = QString("#ifndef GUARD_CONSTANTS_MAPS_H\n");
+    text += QString("#define GUARD_CONSTANTS_MAPS_H\n");
+    text += QString("\n");
+
+    int groupNum = 0;
+    for (QStringList mapNames : groupedMapNames) {
+        text += QString("// Map Group %1\n").arg(groupNum);
+        int maxLength = 0;
+        for (QString mapName : mapNames) {
+            QString mapConstantName = mapNamesToMapConstants->value(mapName);
+            if (mapConstantName.length() > maxLength)
+                maxLength = mapConstantName.length();
+        }
+        int groupIndex = 0;
+        for (QString mapName : mapNames) {
+            QString mapConstantName = mapNamesToMapConstants->value(mapName);
+            text += QString("#define %1%2(%3 | (%4 << 8))\n")
+                    .arg(mapConstantName)
+                    .arg(QString(" ").repeated(maxLength - mapConstantName.length() + 1))
+                    .arg(groupIndex)
+                    .arg(groupNum);
+            groupIndex++;
+        }
+        text += QString("\n");
+        groupNum++;
+    }
+
+    text += QString("\n");
+    text += QString("#define MAP_NONE (0x7F | (0x7F << 8))\n");
+    text += QString("#define MAP_UNDEFINED (0xFF | (0xFF << 8))\n\n\n");
+    text += QString("#define MAP_GROUP(map) (MAP_##map >> 8)\n");
+    text += QString("#define MAP_NUM(map) (MAP_##map & 0xFF)\n\n");
+    text += QString("#endif  // GUARD_CONSTANTS_MAPS_H\n");
+    saveTextFile(root + "/include/constants/maps.h", text);
+}
+
 void Project::getTilesets(Map* map) {
     map->tileset_primary = getTileset(map->tileset_primary_label);
     map->tileset_secondary = getTileset(map->tileset_secondary_label);
 }
 
 QString Project::getBlockdataPath(Map* map) {
-    QString text = readTextFile(root + "/data/maps/_assets.inc");
+    QString text = readTextFile(getMapAssetsFilepath());
     QStringList *values = getLabelValues(parse(text), map->blockdata_label);
     QString path;
     if (!values->isEmpty()) {
 }
 
 QString Project::getMapBorderPath(Map *map) {
-    QString text = readTextFile(root + "/data/maps/_assets.inc");
+    QString text = readTextFile(getMapAssetsFilepath());
     QStringList *values = getLabelValues(parse(text), map->border_label);
     QString path;
     if (!values->isEmpty()) {
 }
 
 void Project::loadBlockdata(Map* map) {
+    if (!map->isPersistedToFile) {
+        return;
+    }
+
     QString path = getBlockdataPath(map);
     map->blockdata = readBlockdata(path);
 }
 
+void Project::setNewMapBlockdata(Map* map) {
+    Blockdata *blockdata = new Blockdata;
+    for (int i = 0; i < map->getWidth() * map->getHeight(); i++) {
+        blockdata->addBlock(qint16(0x3001));
+    }
+    map->blockdata = blockdata;
+}
+
 void Project::loadMapBorder(Map *map) {
+    if (!map->isPersistedToFile) {
+        return;
+    }
+
     QString path = getMapBorderPath(map);
     map->border = readBlockdata(path);
 }
 
+void Project::setNewMapBorder(Map *map) {
+    Blockdata *blockdata = new Blockdata;
+    blockdata->addBlock(qint16(0x01D4));
+    blockdata->addBlock(qint16(0x01D5));
+    blockdata->addBlock(qint16(0x01DC));
+    blockdata->addBlock(qint16(0x01DD));
+    map->border = blockdata;
+}
+
+void Project::saveMapBorder(Map *map) {
+    QString path = getMapBorderPath(map);
+    writeBlockdata(path, map->border);
+}
+
 void Project::saveBlockdata(Map* map) {
     QString path = getBlockdataPath(map);
     writeBlockdata(path, map->blockdata);
 }
 
 void Project::saveMap(Map *map) {
-    saveBlockdata(map);
+    // Create/Modify a few collateral files for brand new maps.
+    if (!map->isPersistedToFile) {
+        QString newMapDataDir = QString(root + "/data/maps/%1").arg(map->name);
+        if (!QDir::root().mkdir(newMapDataDir)) {
+            qDebug() << "Error: failed to create directory for new map. " << newMapDataDir;
+        }
+
+        // TODO: In the future, these files needs more structure to allow for proper parsing/saving.
+        // Create file data/scripts/maps/<map_name>.inc
+        QString text = QString("%1_MapScripts::\n\t.byte 0\n").arg(map->name);
+        saveTextFile(root + "/data/scripts/maps/" + map->name + ".inc", text);
+
+        // Create file data/text/maps/<map_name>.inc
+        saveTextFile(root + "/data/text/maps/" + map->name + ".inc", "\n");
+
+        // Simply append to data/event_scripts.s.
+        text = QString("\n\t.include \"data/scripts/maps/%1.inc\"\n").arg(map->name);
+        text += QString("\t.include \"data/text/maps/%1.inc\"\n").arg(map->name);
+        appendTextFile(root + "/data/event_scripts.s", text);
+
+        // Simply append to data/map_events.s.
+        text = QString("\n\t.include \"data/maps/events/%1.inc\"\n").arg(map->name);
+        appendTextFile(root + "/data/map_events.s", text);
+
+        // Simply append to data/maps/headers.inc.
+        text = QString("\t.include \"data/maps/%1/header.inc\"\n").arg(map->name);
+        appendTextFile(root + "/data/maps/headers.inc", text);
+    }
+
+    saveMapBorder(map);
     saveMapHeader(map);
+    saveBlockdata(map);
     saveMapEvents(map);
+
+    // Update global data structures with current map data.
+    updateMapAttributes(map);
+
+    map->isPersistedToFile = true;
+}
+
+void Project::updateMapAttributes(Map* map) {
+    mapAttributesTableMaster.insert(map->index.toInt(nullptr, 0), map->name);
+
+    // Deep copy
+    QMap<QString, QString> attrs = mapAttributes.value(map->name);
+    attrs.detach();
+    mapAttributesMaster.insert(map->name, attrs);
+}
+
+void Project::saveAllDataStructures() {
+    saveMapAttributesTable();
+    saveAllMapAttributes();
+    saveMapGroupsTable();
+    saveMapConstantsHeader();
 }
 
 void Project::loadTilesetAssets(Tileset* tileset) {
     }
 }
 
+void Project::appendTextFile(QString path, QString text) {
+    QFile file(path);
+    if (file.open(QIODevice::Append)) {
+        file.write(text.toUtf8());
+    } else {
+        qDebug() << QString("Could not open '%1' for appending: ").arg(path) + file.errorString();
+    }
+}
+
 void Project::readMapGroups() {
     QString text = readTextFile(root + "/data/maps/_groups.inc");
     if (text.isNull()) {
         }
     }
 
-    QList<QStringList*> *groupedMaps = new QList<QStringList*>;
+    QList<QStringList> groupedMaps;
     for (int i = 0; i < groups->length(); i++) {
-        QStringList *list = new QStringList;
-        groupedMaps->append(list);
+        groupedMaps.append(QStringList());
     }
 
     QStringList *maps = new QStringList;
             if (group != -1) {
                 for (int j = 1; j < params.length(); j++) {
                     QString mapName = params.value(j);
-                    QStringList *list = groupedMaps->value(group);
-                    list->append(mapName);
+                    groupedMaps[group].append(mapName);
                     maps->append(mapName);
+                    map_groups->insert(mapName, group);
 
                     // Build the mapping and reverse mapping between map constants and map names.
                     QString mapConstant = Map::mapConstantFromName(mapName);
-                    mapConstantsToMapNames.insert(mapConstant, mapName);
-                    mapNamesToMapConstants.insert(mapName, mapConstant);
+                    mapConstantsToMapNames->insert(mapConstant, mapName);
+                    mapNamesToMapConstants->insert(mapName, mapConstant);
                 }
             }
         }
     mapNames = maps;
 }
 
+Map* Project::addNewMapToGroup(QString mapName, int groupNum) {
+    int mapIndex = mapAttributesTable.count() + 1;
+    mapAttributesTable.insert(mapIndex, mapName);
+
+    // Setup new map in memory, but don't write to file until map is actually saved later.
+    mapNames->append(mapName);
+    map_groups->insert(mapName, groupNum);
+    groupedMapNames[groupNum].append(mapName);
+
+    Map *map = new Map;
+    map->isPersistedToFile = false;
+    map->setName(mapName);
+    mapConstantsToMapNames->insert(map->constantName, map->name);
+    mapNamesToMapConstants->insert(map->name, map->constantName);
+    setNewMapHeader(map, mapIndex);
+    setNewMapAttributes(map);
+    getTilesets(map);
+    setNewMapBlockdata(map);
+    setNewMapBorder(map);
+    setNewMapEvents(map);
+    setNewMapConnections(map);
+    map->commit();
+    map->history.save();
+    map_cache->insert(mapName, map);
+
+    return map;
+}
+
+QString Project::getNewMapName() {
+    // Ensure default name doesn't already exist.
+    int i = 0;
+    QString newMapName;
+    do {
+        newMapName = QString("NewMap%1").arg(++i);
+    } while (mapNames->contains(newMapName));
+
+    return newMapName;
+}
+
 QList<QStringList>* Project::parse(QString text) {
     Asm *parser = new Asm;
     return parser->parse(text);
             text += QString(", %1").arg(warp->get("y"));
             text += QString(", %1").arg(warp->get("elevation"));
             text += QString(", %1").arg(warp->get("destination_warp"));
-            text += QString(", %1").arg(mapNamesToMapConstants[warp->get("destination_map_name")]);
+            text += QString(", %1").arg(mapNamesToMapConstants->value(warp->get("destination_map_name")));
             text += "\n";
         }
         text += "\n";
 }
 
 void Project::readMapEvents(Map *map) {
+    if (!map->isPersistedToFile) {
+        return;
+    }
+
     // lazy
     QString path = root + QString("/data/maps/events/%1.inc").arg(map->name);
     QString text = readTextFile(path);
 
             // Ensure the warp destination map constant is valid before adding it to the warps.
             QString mapConstant = command.value(i++);
-            if (mapConstantsToMapNames.contains(mapConstant)) {
-                warp->put("destination_map_name", mapConstantsToMapNames[mapConstant]);
+            if (mapConstantsToMapNames->contains(mapConstant)) {
+                warp->put("destination_map_name", mapConstantsToMapNames->value(mapConstant));
                 warp->put("event_type", "warp");
                 map->events["warp"].append(warp);
             } else {
     }
 }
 
+void Project::setNewMapEvents(Map *map) {
+    map->object_events_label = "0x0";
+    map->warps_label = "0x0";
+    map->coord_events_label = "0x0";
+    map->bg_events_label = "0x0";
+    map->events["object"].clear();
+    map->events["warp"].clear();
+    map->events["trap"].clear();
+    map->events["trap_weather"].clear();
+    map->events["sign"].clear();
+    map->events["event_hidden_item"].clear();
+    map->events["event_secret_base"].clear();
+}
+
 QStringList Project::readCArray(QString text, QString label) {
     QStringList list;
 

project.h

 
 #include <QStringList>
 #include <QList>
+#include <QStandardItem>
 
 class Project
 {
     Project();
     QString root;
     QStringList *groupNames = NULL;
-    QList<QStringList*> *groupedMapNames = NULL;
+    QMap<QString, int> *map_groups;
+    QList<QStringList> groupedMapNames;
     QStringList *mapNames = NULL;
-    QMap<QString, QString> mapConstantsToMapNames;
-    QMap<QString, QString> mapNamesToMapConstants;
+    QMap<QString, QString>* mapConstantsToMapNames;
+    QMap<QString, QString>* mapNamesToMapConstants;
+    QMap<int, QString> mapAttributesTable;
+    QMap<int, QString> mapAttributesTableMaster;
+    QMap<QString, QMap<QString, QString>> mapAttributes;
+    QMap<QString, QMap<QString, QString>> mapAttributesMaster;
+
 
     QMap<QString, Map*> *map_cache;
     Map* loadMap(QString);
 
     QString readTextFile(QString path);
     void saveTextFile(QString path, QString text);
+    void appendTextFile(QString path, QString text);
 
     void readMapGroups();
+    Map* addNewMapToGroup(QString mapName, int groupNum);
+    QString getNewMapName();
     QString getProjectTitle();
 
     QList<QStringList>* getLabelMacros(QList<QStringList>*, QString);
     QStringList* getLabelValues(QList<QStringList>*, QString);
     void readMapHeader(Map*);
+    void readMapAttributesTable();
+    void readAllMapAttributes();
     void readMapAttributes(Map*);
     void getTilesets(Map*);
     void loadTilesetAssets(Tileset*);
 
     QString getBlockdataPath(Map*);
     void saveBlockdata(Map*);
+    void saveMapBorder(Map*);
     void writeBlockdata(QString, Blockdata*);
     void saveAllMaps();
     void saveMap(Map*);
-    void saveMapHeader(Map*);
+    void saveAllDataStructures();
+    void saveAllMapAttributes();
+    void saveMapGroupsTable();
+    void saveMapConstantsHeader();
 
     QList<QStringList>* parse(QString text);
     QStringList getSongNames();
     QStringList readCArray(QString text, QString label);
     QString readCIncbin(QString text, QString label);
     QMap<QString, int> readCDefines(QString text, QStringList prefixes);
+private:
+    QString getMapAttributesTableFilepath();
+    QString getMapAssetsFilepath();
+    void saveMapHeader(Map*);
+    void saveMapAttributesTable();
+    void updateMapAttributes(Map* map);
+
+    void setNewMapHeader(Map* map, int mapIndex);
+    void setNewMapAttributes(Map* map);
+    void setNewMapBlockdata(Map* map);
+    void setNewMapBorder(Map *map);
+    void setNewMapEvents(Map *map);
+    void setNewMapConnections(Map *map);
 };
 
 #endif // PROJECT_H