Leahnaya/porymap
1
0
Fork 0
mirror of https://github.com/huderlem/porymap.git synced 2026-03-21 17:45:44 -05:00
Code Issues Actions Packages Projects Releases Wiki Activity
dc4b1ef93a
porymap/src/project.cpp

3500 lines
151 KiB
C++
Raw Blame History

#include "project.h"
#include "config.h"
#include "history.h"
#include "log.h"
#include "parseutil.h"
#include "paletteutil.h"
#include "tile.h"
#include "tileset.h"
#include "map.h"
#include "filedialog.h"
#include "validator.h"
#include "orderedjson.h"
#include "utility.h"
#include <QDir>
#include <QJsonArray>
#include <QJsonDocument>
#include <QJsonObject>
#include <QJsonValue>
#include <QFile>
#include <QTextStream>
#include <QStandardItem>
#include <QMessageBox>
#include <QRegularExpression>
#include <algorithm>
int Project::num_tiles_primary = 512;
int Project::num_tiles_total = 1024;
int Project::num_metatiles_primary = 512;
int Project::num_pals_primary = 6;
int Project::num_pals_total = 13;
Project::Project(QObject *parent) :
QObject(parent)
{ }
Project::~Project()
{
clearMaps();
clearTilesetCache();
clearMapLayouts();
clearEventGraphics();
clearHealLocations();
QPixmapCache::clear();
}
void Project::setRoot(const QString &dir) {
this->root = dir;
FileDialog::setDirectory(dir);
this->parser.setRoot(dir);
}
// Before attempting the initial project load we should check for a few notable files.
// If all are missing then we can warn the user, they may have accidentally selected the wrong folder.
bool Project::sanityCheck() {
// The goal with the file selection is to pick files that are important enough that any reasonable project would have
// at least 1 in the expected location, but unique enough that they're unlikely to overlap with a completely unrelated
// directory (e.g. checking for 'data/maps/' is a bad choice because it's too generic, pokeyellow would pass for instance)
static const QSet<ProjectFilePath> pathsToCheck = {
ProjectFilePath::json_map_groups,
ProjectFilePath::json_layouts,
ProjectFilePath::tilesets_headers,
ProjectFilePath::global_fieldmap,
};
for (auto pathId : pathsToCheck) {
const QString path = QString("%1/%2").arg(this->root).arg(projectConfig.getFilePath(pathId));
QFileInfo fileInfo(path);
if (fileInfo.exists() && fileInfo.isFile())
return true;
}
return false;
}
// Porymap projects have no standardized way for Porymap to determine whether they're compatible as of the latest breaking changes.
// We can use the project's git history (if it has one, and we're able to get it) to make a reasonable guess.
// We know the hashes of the commits in the base repos that contain breaking changes, so if we find one of these then the project
// should support at least up to that Porymap major version. If this fails for any reason it returns a version of -1.
int Project::getSupportedMajorVersion(QString *errorOut) {
// This has relatively tight timeout windows (500ms for each process, compared to the default 30,000ms). This version check
// is not important enough to significantly slow down project launch, we'd rather just timeout.
const int timeoutLimit = 500;
const int failureVersion = -1;
QString gitName = "git";
QString gitPath = QStandardPaths::findExecutable(gitName);
if (gitPath.isEmpty()) {
if (errorOut) *errorOut = QString("Unable to locate %1.").arg(gitName);
return failureVersion;
}
QProcess process;
process.setWorkingDirectory(this->root);
process.setProgram(gitPath);
process.setReadChannel(QProcess::StandardOutput);
process.setStandardInputFile(QProcess::nullDevice()); // We won't have any writing to do.
// First we need to know which (if any) known history this project belongs to.
// We'll get the root commit, then compare it to the known root commits for the base project repos.
static const QStringList args_getRootCommit = { "rev-list", "--max-parents=0", "HEAD" };
process.setArguments(args_getRootCommit);
process.start();
if (!process.waitForFinished(timeoutLimit) || process.exitStatus() != QProcess::ExitStatus::NormalExit || process.exitCode() != 0) {
if (errorOut) {
*errorOut = QStringLiteral("Failed to identify commit history");
if (process.error() != QProcess::UnknownError && !process.errorString().isEmpty()) {
errorOut->append(QString(": %1").arg(process.errorString()));
} else {
process.setReadChannel(QProcess::StandardError);
QString error = QString(process.readLine()).remove('\n');
if (!error.isEmpty()) errorOut->append(QString(": %1").arg(error));
}
}
return failureVersion;
}
const QString rootCommit = QString(process.readLine()).remove('\n');
// The keys in this map are the hashes of the root commits for each of the 3 base repos.
// The values are a list of pairs, where the first element is a major version number, and the
// second element is the hash of the earliest commit that supports that major version.
static const QMap<QString, QList<QPair<int, QString>>> historyMap = {
// pokeemerald
{"33b799c967fd63d04afe82eecc4892f3e45781b3", {
{6, "0c32d840fae64c612b01ca8b004d1f95b7f798ba"},
{5, "c76beed98990a57c84d3930190fd194abfedf7e8"},
{4, "cb5b8da77b9ba6837fcc8c5163bedc5008b12c2c"},
{3, "204c431993dad29661a9ff47326787cd0cf381e6"},
{2, "cdae0c1444bed98e652c87dc3e3edcecacfef8be"},
{1, ""}
}},
// pokefirered
{"670fef77ac4d9116d5fdc28c0da40622919a062b", {
{6, "f60d28ceb58cd6e7064e34c34e56d09b84420355"},
{5, "52591dcee42933d64f60c59276fc13c3bb89c47b"},
{4, "200c82e01a94dbe535e6ed8768d8afad4444d4d2"},
}},
// pokeruby
{"1362b60f3467f0894d55e82f3294980b6373021d", {
{6, "5eb76d89ce5c41feeba848abe10b8e52b1add84c"},
{5, "d99cb43736dd1d4ee4820f838cb259d773d8bf25"},
{4, "f302fcc134bf354c3655e3423be68fd7a99cb396"},
{3, "b4f4d2c0f03462dcdf3492aad27890294600eb2e"},
{2, "0e8ccfc4fd3544001f4c25fafd401f7558bdefba"},
{1, ""}
}},
};
if (!historyMap.contains(rootCommit)) {
// Either this repo does not share history with one of the base repos, or we got some unexpected result.
if (errorOut) *errorOut = QStringLiteral("Unrecognized commit history");
return failureVersion;
}
// We now know which base repo that the user's repo shares history with.
// Next we check to see if it contains the changes required to support particular major versions of Porymap.
// We'll start with the most recent major version and work backwards.
for (const auto &pair : historyMap.value(rootCommit)) {
int versionNum = pair.first;
QString commitHash = pair.second;
if (commitHash.isEmpty()) {
// An empty commit hash means 'consider any point in the history a supported version'
return versionNum;
}
process.setArguments({ "merge-base", "--is-ancestor", commitHash, "HEAD" });
process.start();
if (!process.waitForFinished(timeoutLimit) || process.exitStatus() != QProcess::ExitStatus::NormalExit) {
if (errorOut) {
*errorOut = QStringLiteral("Failed to search commit history");
if (process.error() != QProcess::UnknownError && !process.errorString().isEmpty()) {
errorOut->append(QString(": %1").arg(process.errorString()));
} else {
process.setReadChannel(QProcess::StandardError);
QString error = QString(process.readLine()).remove('\n');
if (!error.isEmpty()) errorOut->append(QString(": %1").arg(error));
}
}
return failureVersion;
}
if (process.exitCode() == 0) {
// Identified a supported major version
return versionNum;
}
}
// We recognized the commit history, but it's too old for any version of Porymap to support.
return 0;
}
bool Project::load() {
this->parser.setUpdatesSplashScreen(true);
resetFileWatcher();
resetFileCache();
this->disabledSettingsNames.clear();
bool success = readGlobalConstants()
&& readMapLayouts()
&& readRegionMapSections()
&& readItemNames()
&& readFlagNames()
&& readVarNames()
&& readMovementTypes()
&& readInitialFacingDirections()
&& readMapTypes()
&& readMapBattleScenes()
&& readWeatherNames()
&& readCoordEventWeatherNames()
&& readSecretBaseIds()
&& readBgEventFacingDirections()
&& readTrainerTypes()
&& readMetatileBehaviors()
&& readFieldmapProperties()
&& readFieldmapMasks()
&& readTilesetLabels()
&& readTilesetMetatileLabels()
&& readMiscellaneousConstants()
&& readSpeciesIconPaths()
&& readWildMonData()
&& readEventScriptLabels()
&& readObjEventGfxConstants()
&& readEventGraphics()
&& readSongNames()
&& readMapGroups()
&& readHealLocations();
if (success) {
// No need to do this if something failed to load.
// (and in fact we shouldn't, because they contain
// assumptions that some things have loaded correctly).
initNewLayoutSettings();
initNewMapSettings();
applyParsedLimits();
logFileWatchStatus();
}
this->parser.setUpdatesSplashScreen(false);
return success;
}
void Project::resetFileCache() {
this->parser.clearFileCache();
const QSet<QString> filepaths = {
// Whenever we load a tileset we'll need to parse some data from these files, so we cache them to avoid the overhead of opening the files.
// We don't know yet whether the project uses C or asm tileset data, so try to cache both (we'll ignore errors from missing files).
projectConfig.getFilePath(ProjectFilePath::tilesets_headers_asm),
projectConfig.getFilePath(ProjectFilePath::tilesets_graphics_asm),
projectConfig.getFilePath(ProjectFilePath::tilesets_metatiles_asm),
projectConfig.getFilePath(ProjectFilePath::tilesets_headers),
projectConfig.getFilePath(ProjectFilePath::tilesets_graphics),
projectConfig.getFilePath(ProjectFilePath::tilesets_metatiles),
// We need separate sets of constants from these files
projectConfig.getFilePath(ProjectFilePath::constants_map_types),
projectConfig.getFilePath(ProjectFilePath::global_fieldmap),
projectConfig.getFilePath(ProjectFilePath::constants_weather),
};
for (const auto &path : filepaths) {
if (this->parser.cacheFile(path)) {
watchFile(path);
}
}
}
QString Project::getProjectTitle() const {
if (!root.isNull()) {
return root.section('/', -1);
} else {
return QString();
}
}
void Project::clearMaps() {
qDeleteAll(this->maps);
this->maps.clear();
this->loadedMapNames.clear();
}
void Project::clearTilesetCache() {
qDeleteAll(this->tilesetCache);
this->tilesetCache.clear();
}
Map* Project::loadMap(const QString &mapName) {
if (mapName == getDynamicMapName()) {
// Silently ignored, caller is expected to handle this if they want this to be an error.
return nullptr;
}
// Some maps are ignored while opening the project because they have invalid or incomplete data.
// We already logged a warning about this, but now that we're trying to load the map it's an error.
auto it = this->erroredMaps.constFind(mapName);
if (it != this->erroredMaps.constEnd()) {
logError(it.value());
return nullptr;
}
Map* map = this->maps.value(mapName);
if (!map) {
logError(QString("Unknown map name '%1'.").arg(mapName));
return nullptr;
}
if (isLoadedMap(mapName))
return map;
if (!loadMapData(map))
return nullptr;
// Load map layout
if (map->isPersistedToFile() && !map->hasUnsavedChanges()) {
if (!loadLayout(map->layoutId()))
return nullptr;
}
this->loadedMapNames.insert(mapName);
emit mapLoaded(map);
return map;
}
Layout *Project::loadLayout(const QString &layoutId) {
Layout *layout = this->mapLayouts.value(layoutId);
if (!layout) {
logError(QString("Unknown layout ID '%1'.").arg(layoutId));
return nullptr;
}
if (isLoadedLayout(layoutId))
return layout;
// Force these to run even if one fails
bool loadedTilesets = loadLayoutTilesets(layout);
bool loadedBlockdata = layout->loadBlockdata(this->root);
bool loadedBorder = layout->loadBorder(this->root);
if (!loadedTilesets || !loadedBlockdata || !loadedBorder) {
// Error should already be logged.
return nullptr;
}
this->loadedLayoutIds.insert(layoutId);
return layout;
}
QSet<QString> Project::getTopLevelMapFields() const {
QSet<QString> fields = {
"id",
"name",
"layout",
"music",
"region_map_section",
"requires_flash",
"weather",
"map_type",
"show_map_name",
"battle_scene",
"connections",
"object_events",
"warp_events",
"coord_events",
"bg_events",
"shared_events_map",
"shared_scripts_map",
};
if (projectConfig.mapAllowFlagsEnabled) {
fields.insert("allow_cycling");
fields.insert("allow_escaping");
fields.insert("allow_running");
}
if (projectConfig.floorNumberEnabled) {
fields.insert("floor_number");
}
return fields;
}
QJsonDocument Project::readMapJson(const QString &mapName, QString *error) {
// Note: We are explicitly not adding mapFilepath to the fileWatcher here.
// All map.json files are read at launch, and adding them all to the filewatcher
// can easily exceed the 256 file limit that exists on some platforms.
const QString mapFilepath = Map::getJsonFilepath(mapName);
QJsonDocument doc;
if (!parser.tryParseJsonFile(&doc, mapFilepath, error)) {
if (error) {
error->prepend(QString("Failed to read map data from '%1': ").arg(mapFilepath));
}
}
return doc;
}
bool Project::loadMapEvent(Map *map, QJsonObject json, Event::Type defaultType) {
QString typeString = ParseUtil::jsonToQString(json.take("type"));
Event::Type type = typeString.isEmpty() ? defaultType : Event::typeFromJsonKey(typeString);
Event* event = Event::create(type);
if (!event) {
return false;
}
if (!event->loadFromJson(json, this)) {
delete event;
return false;
}
map->addEvent(event);
return true;
}
bool Project::loadMapData(Map* map) {
if (!map->isPersistedToFile()) {
return true;
}
QString error;
QJsonDocument mapDoc = readMapJson(map->name(), &error);
if (!error.isEmpty()) {
logError(error);
return false;
}
QJsonObject mapObj = mapDoc.object();
QString name = ParseUtil::jsonToQString(mapObj.take("name"));
if (name != map->name()) {
logWarn(QString("Mismatched name '%1' for map '%2' will be overwritten.").arg(name).arg(map->name()));
}
// We should already know the map constant ID from the initial project launch, but we'll ensure it's correct here anyway.
map->setConstantName(ParseUtil::jsonToQString(mapObj.take("id")));
this->mapConstantsToMapNames.insert(map->constantName(), map->name());
const QString layoutId = ParseUtil::jsonToQString(mapObj.take("layout"));
Layout* layout = this->mapLayouts.value(layoutId);
if (!layout) {
// We've already verified layout IDs on project launch and ignored maps with invalid IDs, so this shouldn't happen.
logError(QString("Cannot load map with unknown layout ID '%1'").arg(layoutId));
return false;
}
map->setLayout(layout);
map->header()->setSong(ParseUtil::jsonToQString(mapObj.take("music")));
map->header()->setLocation(ParseUtil::jsonToQString(mapObj.take("region_map_section")));
map->header()->setRequiresFlash(ParseUtil::jsonToBool(mapObj.take("requires_flash")));
map->header()->setWeather(ParseUtil::jsonToQString(mapObj.take("weather")));
map->header()->setType(ParseUtil::jsonToQString(mapObj.take("map_type")));
map->header()->setShowsLocationName(ParseUtil::jsonToBool(mapObj.take("show_map_name")));
map->header()->setBattleScene(ParseUtil::jsonToQString(mapObj.take("battle_scene")));
if (projectConfig.mapAllowFlagsEnabled) {
map->header()->setAllowsBiking(ParseUtil::jsonToBool(mapObj.take("allow_cycling")));
map->header()->setAllowsEscaping(ParseUtil::jsonToBool(mapObj.take("allow_escaping")));
map->header()->setAllowsRunning(ParseUtil::jsonToBool(mapObj.take("allow_running")));
}
if (projectConfig.floorNumberEnabled) {
map->header()->setFloorNumber(ParseUtil::jsonToInt(mapObj.take("floor_number")));
}
map->setSharedEventsMap(ParseUtil::jsonToQString(mapObj.take("shared_events_map")));
map->setSharedScriptsMap(ParseUtil::jsonToQString(mapObj.take("shared_scripts_map")));
// Events
map->resetEvents();
static const QMap<QString, Event::Type> defaultEventTypes = {
// Map of the expected keys for each event group, and the default type of that group.
// If the default type is Type::None then each event must specify its type, or its an error.
{"object_events", Event::Type::Object},
{"warp_events", Event::Type::Warp},
{"coord_events", Event::Type::None},
{"bg_events", Event::Type::None},
};
for (auto i = defaultEventTypes.constBegin(); i != defaultEventTypes.constEnd(); i++) {
QString eventGroupKey = i.key();
Event::Type defaultType = i.value();
const QJsonArray eventsJsonArr = mapObj.take(eventGroupKey).toArray();
for (int i = 0; i < eventsJsonArr.size(); i++) {
if (!loadMapEvent(map, eventsJsonArr.at(i).toObject(), defaultType)) {
logError(QString("Failed to load event for %1, in %2 at index %3.").arg(map->name()).arg(eventGroupKey).arg(i));
}
}
}
// Heal locations are global. Populate the Map's heal location events using our global array.
const QList<HealLocationEvent*> hlEvents = this->healLocations.value(map->constantName());
for (const auto &event : hlEvents) {
map->addEvent(event->duplicate());
}
map->deleteConnections();
QJsonArray connectionsArr = mapObj.take("connections").toArray();
if (!connectionsArr.isEmpty()) {
for (int i = 0; i < connectionsArr.size(); i++) {
QJsonObject connectionObj = connectionsArr[i].toObject();
const QString direction = ParseUtil::jsonToQString(connectionObj.take("direction"));
const int offset = ParseUtil::jsonToInt(connectionObj.take("offset"));
const QString mapConstant = ParseUtil::jsonToQString(connectionObj.take("map"));
auto connection = new MapConnection(this->mapConstantsToMapNames.value(mapConstant, mapConstant), direction, offset);
connection->setCustomData(connectionObj);
map->loadConnection(connection);
}
}
map->setCustomAttributes(mapObj);
return true;
}
Map *Project::createNewMap(const Project::NewMapSettings &settings, const Map* toDuplicate) {
Map *map = toDuplicate ? new Map(*toDuplicate) : new Map;
map->setName(settings.name);
map->setHeader(settings.header);
map->setNeedsHealLocation(settings.canFlyTo);
// Generate a unique MAP constant.
map->setConstantName(toUniqueIdentifier(map->expectedConstantName()));
if (!this->groupNames.contains(settings.group)) {
// Adding map to a map group that doesn't exist yet.
if (isValidNewIdentifier(settings.group)) {
addNewMapGroup(settings.group);
} else {
logError(QString("Cannot create new map with invalid map group name '%1'.").arg(settings.group));
delete map;
return nullptr;
}
}
Layout *layout = this->mapLayouts.value(settings.layout.id);
if (!layout) {
// Layout doesn't already exist, create it.
layout = createNewLayout(settings.layout, toDuplicate ? toDuplicate->layout() : nullptr);
if (!layout) {
// Layout creation failed.
delete map;
return nullptr;
}
} else {
// This layout already exists. Make sure it's loaded.
if (!loadLayout(settings.layout.id)) {
// Layout failed to load. For now we can just record the ID.
map->setLayoutId(settings.layout.id);
}
}
map->setLayout(layout);
// Try to record the MAPSEC name in case this is a new name.
addNewMapsec(map->header()->location());
this->groupNameToMapNames[settings.group].append(map->name());
this->mapConstantsToMapNames.insert(map->constantName(), map->name());
this->alphabeticalMapNames.append(map->name());
Util::numericalModeSort(this->alphabeticalMapNames);
map->setIsPersistedToFile(false);
this->maps.insert(map->name(), map);
emit mapCreated(map, settings.group);
return map;
}
Layout *Project::createNewLayout(const Layout::Settings &settings, const Layout *toDuplicate) {
if (this->mapLayouts.contains(settings.id))
return nullptr;
Layout *layout = toDuplicate ? new Layout(*toDuplicate) : new Layout();
layout->id = settings.id;
layout->name = settings.name;
layout->width = settings.width;
layout->height = settings.height;
layout->border_width = settings.borderWidth;
layout->border_height = settings.borderHeight;
layout->tileset_primary_label = settings.primaryTilesetLabel;
layout->tileset_secondary_label = settings.secondaryTilesetLabel;
// If a special folder name was specified (as in the case when we're creating a layout for a new map) then use that name.
// Otherwise the new layout's folder name will just be the layout's name.
const QString folderName = !settings.folderName.isEmpty() ? settings.folderName : layout->name;
const QString folderPath = projectConfig.getFilePath(ProjectFilePath::data_layouts_folders) + folderName;
layout->newFolderPath = folderPath;
layout->border_path = folderPath + "/border.bin";
layout->blockdata_path = folderPath + "/map.bin";
if (layout->blockdata.isEmpty()) {
// Fill layout using default fill settings
setNewLayoutBlockdata(layout);
}
if (layout->border.isEmpty()) {
// Fill border using default fill settings
setNewLayoutBorder(layout);
}
// No need for a full load, we already have all the blockdata.
if (!loadLayoutTilesets(layout)) {
delete layout;
return nullptr;
}
this->mapLayouts.insert(layout->id, layout);
this->orderedLayoutIds.append(layout->id);
this->loadedLayoutIds.insert(layout->id);
this->alphabeticalLayoutIds.append(layout->id);
Util::numericalModeSort(this->alphabeticalLayoutIds);
emit layoutCreated(layout);
return layout;
}
void Project::clearMapLayouts() {
qDeleteAll(this->mapLayouts);
this->mapLayouts.clear();
qDeleteAll(this->mapLayoutsMaster);
this->mapLayoutsMaster.clear();
this->alphabeticalLayoutIds.clear();
this->orderedLayoutIds.clear();
this->orderedLayoutIdsMaster.clear();
this->loadedLayoutIds.clear();
this->customLayoutsData = QJsonObject();
this->failedLayoutsData.clear();
}
bool Project::readMapLayouts() {
clearMapLayouts();
const QString layoutsFilepath = projectConfig.getFilePath(ProjectFilePath::json_layouts);
watchFile(layoutsFilepath);
QJsonDocument layoutsDoc;
QString error;
if (!parser.tryParseJsonFile(&layoutsDoc, layoutsFilepath, &error)) {
logError(QString("Failed to read map layouts from '%1': %2").arg(layoutsFilepath).arg(error));
return false;
}
QJsonObject layoutsObj = layoutsDoc.object();
this->layoutsLabel = ParseUtil::jsonToQString(layoutsObj.take("layouts_table_label"));
if (this->layoutsLabel.isEmpty()) {
this->layoutsLabel = "gMapLayouts";
logWarn(QString("'layouts_table_label' value is missing from %1. Defaulting to %2")
.arg(layoutsFilepath)
.arg(layoutsLabel));
}
QJsonArray layouts = layoutsObj.take("layouts").toArray();
for (int i = 0; i < layouts.size(); i++) {
QJsonObject layoutObj = layouts[i].toObject();
if (layoutObj.isEmpty())
continue;
QScopedPointer<Layout> layout(new Layout());
layout->id = ParseUtil::jsonToQString(layoutObj.take("id"));
if (layout->id.isEmpty()) {
// Use name to identify it in the warning, if available.
QString name = ParseUtil::jsonToQString(layoutObj["name"]);
if (name.isEmpty()) name = QString("Layout %1 (unnamed)").arg(i);
logWarn(QString("Missing 'id' value for %1 in %2").arg(name).arg(layoutsFilepath));
this->failedLayoutsData.append(layouts[i].toObject());
continue;
}
if (this->mapLayouts.contains(layout->id)) {
logWarn(QString("Duplicate layout entry for %1 in %2 will be ignored.").arg(layout->id).arg(layoutsFilepath));
this->failedLayoutsData.append(layouts[i].toObject());
continue;
}
layout->name = ParseUtil::jsonToQString(layoutObj.take("name"));
if (layout->name.isEmpty()) {
logWarn(QString("Missing 'name' value for %1 in %2").arg(layout->id).arg(layoutsFilepath));
this->failedLayoutsData.append(layouts[i].toObject());
continue;
}
layout->width = ParseUtil::jsonToInt(layoutObj.take("width"));
layout->height = ParseUtil::jsonToInt(layoutObj.take("height"));
if (projectConfig.useCustomBorderSize) {
layout->border_width = ParseUtil::jsonToInt(layoutObj.take("border_width"));
layout->border_height = ParseUtil::jsonToInt(layoutObj.take("border_height"));
} else {
layout->border_width = DEFAULT_BORDER_WIDTH;
layout->border_height = DEFAULT_BORDER_HEIGHT;
}
layout->tileset_primary_label = ParseUtil::jsonToQString(layoutObj.take("primary_tileset"));
layout->tileset_secondary_label = ParseUtil::jsonToQString(layoutObj.take("secondary_tileset"));
layout->border_path = ParseUtil::jsonToQString(layoutObj.take("border_filepath"));
layout->blockdata_path = ParseUtil::jsonToQString(layoutObj.take("blockdata_filepath"));
layout->customData = layoutObj;
this->mapLayouts.insert(layout->id, layout->copy());
this->mapLayoutsMaster.insert(layout->id, layout->copy());
this->orderedLayoutIds.append(layout->id);
this->orderedLayoutIdsMaster.append(layout->id);
}
if (this->mapLayouts.isEmpty()) {
logError(QString("Failed to read any map layouts from '%1'. At least one map layout is required.").arg(layoutsFilepath));
return false;
}
this->alphabeticalLayoutIds = this->orderedLayoutIds;
Util::numericalModeSort(this->alphabeticalLayoutIds);
this->customLayoutsData = layoutsObj;
return true;
}
bool Project::saveMapLayouts() {
QString layoutsFilepath = root + "/" + projectConfig.getFilePath(ProjectFilePath::json_layouts);
QFile layoutsFile(layoutsFilepath);
if (!layoutsFile.open(QIODevice::WriteOnly)) {
logError(QString("Could not open '%1' for writing: %2").arg(layoutsFilepath).arg(layoutsFile.errorString()));
return false;
}
OrderedJson::object layoutsObj;
layoutsObj["layouts_table_label"] = this->layoutsLabel;
OrderedJson::array layoutsArr;
for (const QString &layoutId : this->orderedLayoutIdsMaster) {
Layout *layout = this->mapLayoutsMaster.value(layoutId);
OrderedJson::object layoutObj;
layoutObj["id"] = layout->id;
layoutObj["name"] = layout->name;
layoutObj["width"] = layout->width;
layoutObj["height"] = layout->height;
if (projectConfig.useCustomBorderSize) {
layoutObj["border_width"] = layout->border_width;
layoutObj["border_height"] = layout->border_height;
}
layoutObj["primary_tileset"] = layout->tileset_primary_label;
layoutObj["secondary_tileset"] = layout->tileset_secondary_label;
layoutObj["border_filepath"] = layout->border_path;
layoutObj["blockdata_filepath"] = layout->blockdata_path;
OrderedJson::append(&layoutObj, layout->customData);
layoutsArr.push_back(layoutObj);
}
// Append any layouts that were hidden because we failed to load them at launch.
// We do a little extra work to keep the field order the same as successfully-loaded layouts.
for (QJsonObject failedData : this->failedLayoutsData) {
OrderedJson::object layoutObj;
static const QStringList expectedFields = {
"id", "name", "width", "height", "border_width", "border_height",
"primary_tileset", "secondary_tileset", "border_filepath", "blockdata_filepath"
};
for (const auto &field : expectedFields) {
if (failedData.contains(field)) {
layoutObj[field] = OrderedJson::fromQJsonValue(failedData.take(field));
}
}
OrderedJson::append(&layoutObj, failedData);
layoutsArr.push_back(layoutObj);
}
layoutsObj["layouts"] = layoutsArr;
OrderedJson::append(&layoutsObj, this->customLayoutsData);
ignoreWatchedFileTemporarily(layoutsFilepath);
OrderedJson layoutJson(layoutsObj);
OrderedJsonDoc jsonDoc(&layoutJson);
jsonDoc.dump(&layoutsFile);
layoutsFile.close();
return true;
}
bool Project::watchFile(const QString &filename) {
if (!porymapConfig.monitorFiles)
return true;
if (!this->fileWatcher) {
// Only create the file watcher when it's first needed (even an empty QFileSystemWatcher will consume system resources).
this->fileWatcher = new QFileSystemWatcher(this);
QObject::connect(this->fileWatcher, &QFileSystemWatcher::fileChanged, this, &Project::recordFileChange);
}
QString filepath = filename.startsWith(this->root) ? filename : QString("%1/%2").arg(this->root).arg(filename);
if (!this->fileWatcher->addPath(filepath) && !this->fileWatcher->files().contains(filepath)) {
// We failed to watch the file, and this wasn't a file we were already watching.
// Record the filepath for logging later, assuming we should have been able to watch the file.
if (QFileInfo::exists(filepath)) {
this->failedFileWatchPaths.insert(filepath);
}
return false;
}
return true;
}
bool Project::watchFiles(const QStringList &filenames) {
bool success = true;
for (const auto &filename : filenames) {
if (!watchFile(filename)) success = false;
}
return success;
}
bool Project::stopFileWatch(const QString &filename) {
if (!this->fileWatcher)
return true;
QString filepath = filename.startsWith(this->root) ? filename : QString("%1/%2").arg(this->root).arg(filename);
return this->fileWatcher->removePath(filepath);
}
void Project::ignoreWatchedFileTemporarily(const QString &filepath) {
// Ignore any file-change events for this filepath for the next 5 seconds.
this->modifiedFileTimestamps.insert(filepath, QDateTime::currentMSecsSinceEpoch() + 5000);
}
void Project::ignoreWatchedFilesTemporarily(const QStringList &filepaths) {
for (const auto &filepath : filepaths) {
ignoreWatchedFileTemporarily(filepath);
}
}
void Project::recordFileChange(const QString &filepath) {
// --From the Qt manual--
// Note: As a safety measure, many applications save an open file by writing a new file and then deleting the old one.
// In your slot function, you can check watcher.files().contains(path).
// If it returns false, check whether the file still exists and then call addPath() to continue watching it.
if (this->fileWatcher && !this->fileWatcher->files().contains(filepath) && QFileInfo::exists(filepath)) {
this->fileWatcher->addPath(filepath);
}
if (this->modifiedFiles.contains(filepath)) {
// We already recorded a change to this file
return;
}
if (this->modifiedFileTimestamps.contains(filepath)) {
if (QDateTime::currentMSecsSinceEpoch() < this->modifiedFileTimestamps[filepath]) {
// We're still ignoring changes to this file
return;
}
this->modifiedFileTimestamps.remove(filepath);
}
this->modifiedFiles.insert(filepath);
emit fileChanged(filepath);
}
// When calling 'watchFile' we record failures rather than log them immediately.
// We do this primarily to condense the warning if we fail to monitor any files.
void Project::logFileWatchStatus() {
if (!this->fileWatcher)
return;
int numSuccessful = this->fileWatcher->files().length();
int numAttempted = numSuccessful + this->failedFileWatchPaths.count();
if (numAttempted == 0)
return;
if (numSuccessful == 0) {
// We failed to watch every file we tried. As of writing this happens if Porymap is running
// on Windows and the project files are in WSL2. Rather than filling the log by
// outputting a warning for every file, just log that we failed to monitor any of them.
logWarn(QString("Failed to monitor project files"));
return;
} else {
logInfo(QString("Successfully monitoring %1/%2 project files").arg(numSuccessful).arg(numAttempted));
}
for (const auto &failedPath : this->failedFileWatchPaths) {
logWarn(QString("Failed to monitor project file '%1'").arg(failedPath));
}
}
void Project::resetFileWatcher() {
this->failedFileWatchPaths.clear();
delete this->fileWatcher;
this->fileWatcher = nullptr;
}
bool Project::saveMapGroups() {
QString mapGroupsFilepath = QString("%1/%2").arg(root).arg(projectConfig.getFilePath(ProjectFilePath::json_map_groups));
QFile mapGroupsFile(mapGroupsFilepath);
if (!mapGroupsFile.open(QIODevice::WriteOnly)) {
logError(QString("Could not open '%1' for writing: %2").arg(mapGroupsFilepath).arg(mapGroupsFile.errorString()));
return false;
}
OrderedJson::object mapGroupsObj;
OrderedJson::array groupNamesArr;
for (QString groupName : this->groupNames) {
groupNamesArr.push_back(groupName);
}
mapGroupsObj["group_order"] = groupNamesArr;
for (const auto &groupName : this->groupNames) {
OrderedJson::array groupArr;
for (const auto &mapName : this->groupNameToMapNames.value(groupName)) {
if (this->maps.value(mapName) && !this->maps.value(mapName)->isPersistedToFile()) {
// This is a new map that hasn't been saved yet, don't add it to the global map groups list yet.
continue;
}
groupArr.push_back(mapName);
}
mapGroupsObj[groupName] = groupArr;
}
OrderedJson::append(&mapGroupsObj, this->customMapGroupsData);
ignoreWatchedFileTemporarily(mapGroupsFilepath);
OrderedJson mapGroupJson(mapGroupsObj);
OrderedJsonDoc jsonDoc(&mapGroupJson);
jsonDoc.dump(&mapGroupsFile);
mapGroupsFile.close();
return true;
}
bool Project::saveRegionMapSections() {
const QString filepath = QString("%1/%2").arg(this->root).arg(projectConfig.getFilePath(ProjectFilePath::json_region_map_entries));
QFile file(filepath);
if (!file.open(QIODevice::WriteOnly)) {
logError(QString("Could not open '%1' for writing: %2").arg(filepath).arg(file.errorString()));
return false;
}
OrderedJson::array mapSectionArray;
for (const auto &idName : this->mapSectionIdNamesSaveOrder) {
const LocationData location = this->locationData.value(idName);
OrderedJson::object mapSectionObj;
mapSectionObj["id"] = idName;
if (!location.displayName.isEmpty()) {
mapSectionObj["name"] = location.displayName;
}
if (location.map.valid) {
mapSectionObj["x"] = location.map.x;
mapSectionObj["y"] = location.map.y;
mapSectionObj["width"] = location.map.width;
mapSectionObj["height"] = location.map.height;
}
OrderedJson::append(&mapSectionObj, location.custom);
mapSectionArray.append(mapSectionObj);
}
OrderedJson::object object;
object["map_sections"] = mapSectionArray;
OrderedJson::append(&object, this->customMapSectionsData);
ignoreWatchedFileTemporarily(filepath);
OrderedJson json(object);
OrderedJsonDoc jsonDoc(&json);
jsonDoc.dump(&file);
file.close();
return true;
}
bool Project::saveWildMonData() {
if (!this->wildEncountersLoaded) return true;
QString wildEncountersJsonFilepath = QString("%1/%2").arg(root).arg(projectConfig.getFilePath(ProjectFilePath::json_wild_encounters));
QFile wildEncountersFile(wildEncountersJsonFilepath);
if (!wildEncountersFile.open(QIODevice::WriteOnly)) {
logError(QString("Could not open '%1' for writing: %2").arg(wildEncountersJsonFilepath).arg(wildEncountersFile.errorString()));
return false;
}
OrderedJson::object wildEncountersObject;
OrderedJson::array wildEncounterGroups;
OrderedJson::object monHeadersObject;
monHeadersObject["label"] = this->wildMonTableName;
monHeadersObject["for_maps"] = true;
OrderedJson::array fieldsInfoArray;
for (EncounterField fieldInfo : this->wildMonFields) {
OrderedJson::object fieldObject;
OrderedJson::array rateArray;
for (int rate : fieldInfo.encounterRates) {
rateArray.push_back(rate);
}
fieldObject["type"] = fieldInfo.name;
fieldObject["encounter_rates"] = rateArray;
OrderedJson::object groupsObject;
for (auto groupNamePair : fieldInfo.groups) {
QString groupName = groupNamePair.first;
OrderedJson::array subGroupIndices;
std::sort(fieldInfo.groups[groupName].begin(), fieldInfo.groups[groupName].end());
for (int slotIndex : fieldInfo.groups[groupName]) {
subGroupIndices.push_back(slotIndex);
}
groupsObject[groupName] = subGroupIndices;
}
if (!groupsObject.empty()) fieldObject["groups"] = groupsObject;
OrderedJson::append(&fieldObject, fieldInfo.customData);
fieldsInfoArray.append(fieldObject);
}
monHeadersObject["fields"] = fieldsInfoArray;
OrderedJson::array encountersArray;
for (auto keyPair : this->wildMonData) {
QString key = keyPair.first;
for (auto grouplLabelPair : this->wildMonData[key]) {
QString groupLabel = grouplLabelPair.first;
OrderedJson::object encounterObject;
encounterObject["map"] = key;
encounterObject["base_label"] = groupLabel;
WildPokemonHeader encounterHeader = this->wildMonData[key][groupLabel];
for (auto fieldNamePair : encounterHeader.wildMons) {
QString fieldName = fieldNamePair.first;
OrderedJson::object monInfoObject;
WildMonInfo monInfo = encounterHeader.wildMons[fieldName];
monInfoObject["encounter_rate"] = monInfo.encounterRate;
OrderedJson::array monArray;
for (WildPokemon wildMon : monInfo.wildPokemon) {
OrderedJson::object monEntry;
monEntry["min_level"] = wildMon.minLevel;
monEntry["max_level"] = wildMon.maxLevel;
monEntry["species"] = wildMon.species;
OrderedJson::append(&monEntry, wildMon.customData);
monArray.push_back(monEntry);
}
monInfoObject["mons"] = monArray;
OrderedJson::append(&monInfoObject, monInfo.customData);
encounterObject[fieldName] = monInfoObject;
OrderedJson::append(&encounterObject, encounterHeader.customData);
}
encountersArray.push_back(encounterObject);
}
}
monHeadersObject["encounters"] = encountersArray;
OrderedJson::append(&monHeadersObject, this->customWildMonGroupData);
wildEncounterGroups.push_back(monHeadersObject);
OrderedJson::append(&wildEncounterGroups, this->extraEncounterGroups);
wildEncountersObject["wild_encounter_groups"] = wildEncounterGroups;
OrderedJson::append(&wildEncountersObject, this->customWildMonData);
ignoreWatchedFileTemporarily(wildEncountersJsonFilepath);
OrderedJson encounterJson(wildEncountersObject);
OrderedJsonDoc jsonDoc(&encounterJson);
jsonDoc.dump(&wildEncountersFile);
wildEncountersFile.close();
return true;
}
// For a map with a constant of 'MAP_FOO', returns a unique 'HEAL_LOCATION_FOO'.
// Because of how event ID names are checked it doesn't guarantee that the name
// won't be in-use by some map that hasn't been loaded yet.
QString Project::getNewHealLocationName(const Map* map) const {
return !map ? QString() : toUniqueIdentifier(projectConfig.getIdentifier(ProjectIdentifier::define_heal_locations_prefix) + Util::toDefineCase(map->name()));
}
bool Project::saveHealLocations() {
const QString filepath = QString("%1/%2").arg(this->root).arg(projectConfig.getFilePath(ProjectFilePath::json_heal_locations));
QFile file(filepath);
if (!file.open(QIODevice::WriteOnly)) {
logError(QString("Could not open '%1' for writing: %2").arg(filepath).arg(file.errorString()));
return false;
}
// Build the JSON data for output.
QMap<QString, QList<OrderedJson::object>> idNameToJson;
for (const auto &events : this->healLocations) {
for (const auto &event : events) {
idNameToJson[event->getIdName()].append(event->buildEventJson(this));
}
}
// We store Heal Locations in a QMap with map name keys. This makes retrieval by map name easy,
// but it will sort them alphabetically. Project::healLocationSaveOrder lets us better support
// the (perhaps unlikely) user who has designed something with assumptions about the order of the data.
// This also avoids a bunch of diff noise on the first save from Porymap reordering the data.
OrderedJson::array eventJsonArr;
for (const auto &idName : this->healLocationSaveOrder) {
if (!idNameToJson.value(idName).isEmpty()) {
eventJsonArr.push_back(idNameToJson[idName].takeFirst());
}
}
// Save any heal locations that weren't covered above (should be any new data).
for (const auto &objects : idNameToJson) {
for (const auto &object : objects) {
eventJsonArr.push_back(object);
}
}
OrderedJson::object object;
object["heal_locations"] = eventJsonArr;
OrderedJson::append(&object, this->customHealLocationsData);
ignoreWatchedFileTemporarily(filepath);
OrderedJson json(object);
OrderedJsonDoc jsonDoc(&json);
jsonDoc.dump(&file);
file.close();
return true;
}
bool Project::saveTilesets(Tileset *primaryTileset, Tileset *secondaryTileset) {
bool success = saveTilesetMetatileLabels(primaryTileset, secondaryTileset);
if (primaryTileset && !primaryTileset->save())
success = false;
if (secondaryTileset && !secondaryTileset->save())
success = false;
return success;
}
void Project::updateTilesetMetatileLabels(Tileset *tileset) {
if (!tileset) return;
// Erase old labels, then repopulate with new labels
const QString prefix = tileset->getMetatileLabelPrefix();
this->metatileLabelsMap[tileset->name].clear();
for (auto i = tileset->metatileLabels.constBegin(); i != tileset->metatileLabels.constEnd(); i++) {
uint16_t metatileId = i.key();
QString label = i.value();
if (!label.isEmpty()) {
this->metatileLabelsMap[tileset->name][prefix + label] = metatileId;
}
}
}
// Given a map of define names to define values, returns a formatted list of #defines
QString Project::buildMetatileLabelsText(const QMap<QString, uint16_t> defines) {
QStringList labels = defines.keys();
// Setup for pretty formatting.
int longestLength = 0;
for (QString label : labels) {
if (label.size() > longestLength)
longestLength = label.size();
}
// Generate defines text
QString output = QString();
for (QString label : labels) {
QString line = QString("#define %1 %2\n")
.arg(label, -1 * longestLength)
.arg(Metatile::getMetatileIdString(defines[label]));
output += line;
}
return output;
}
bool Project::saveTilesetMetatileLabels(Tileset *primaryTileset, Tileset *secondaryTileset) {
// Skip writing the file if there are no labels in both the new and old sets
if ((!primaryTileset || (metatileLabelsMap[primaryTileset->name].size() == 0 && primaryTileset->metatileLabels.size() == 0))
&& (!secondaryTileset || (metatileLabelsMap[secondaryTileset->name].size() == 0 && secondaryTileset->metatileLabels.size() == 0)))
return true;
updateTilesetMetatileLabels(primaryTileset);
updateTilesetMetatileLabels(secondaryTileset);
// Recreate metatile labels file
const QString guardName = "GUARD_METATILE_LABELS_H";
QString outputText = QString("#ifndef %1\n#define %1\n").arg(guardName);
for (auto i = this->metatileLabelsMap.constBegin(); i != this->metatileLabelsMap.constEnd(); i++) {
const QString tilesetName = i.key();
const QMap<QString, uint16_t> tilesetMetatileLabels = i.value();
if (tilesetMetatileLabels.isEmpty())
continue;
outputText += QString("\n// %1\n%2").arg(tilesetName).arg(buildMetatileLabelsText(tilesetMetatileLabels));
}
if (unusedMetatileLabels.size() != 0) {
// Append any defines originally read from the file that aren't associated with any tileset.
outputText += QString("\n// Other\n");
outputText += buildMetatileLabelsText(unusedMetatileLabels);
}
outputText += QString("\n#endif // %1\n").arg(guardName);
QString filename = projectConfig.getFilePath(ProjectFilePath::constants_metatile_labels);
ignoreWatchedFileTemporarily(root + "/" + filename);
return saveTextFile(root + "/" + filename, outputText);
}
bool Project::loadLayoutTilesets(Layout *layout) {
// Note: Do not replace invalid tileset labels with the default tileset labels here.
// Changing the tilesets like this can require us to load tilesets unnecessarily
// in order to avoid strange behavior (e.g. tile/metatile usage counts changing).
if (layout->tileset_primary_label.isEmpty()) {
logError(QString("Failed to load %1: missing primary tileset label.").arg(layout->name));
return false;
}
if (layout->tileset_secondary_label.isEmpty()) {
logError(QString("Failed to load %1: missing secondary tileset label.").arg(layout->name));
return false;
}
layout->tileset_primary = getTileset(layout->tileset_primary_label);
layout->tileset_secondary = getTileset(layout->tileset_secondary_label);
return layout->tileset_primary && layout->tileset_secondary;
}
Tileset* Project::loadTileset(QString label, Tileset *tileset) {
auto memberMap = Tileset::getHeaderMemberMap(this->usingAsmTilesets);
if (this->usingAsmTilesets) {
// Read asm tileset header. Backwards compatibility
const QString path = projectConfig.getFilePath(ProjectFilePath::tilesets_headers_asm);
const QStringList values = parser.getLabelValues(parser.parseAsm(path), label);
if (values.isEmpty()) {
logError(QString("Failed to find header data in '%1' for tileset '%2'.").arg(path).arg(label));
return nullptr;
}
if (tileset == nullptr) {
tileset = new Tileset;
}
tileset->name = label;
tileset->is_secondary = ParseUtil::gameStringToBool(values.value(memberMap.key("isSecondary")));
tileset->tiles_label = values.value(memberMap.key("tiles"));
tileset->palettes_label = values.value(memberMap.key("palettes"));
tileset->metatiles_label = values.value(memberMap.key("metatiles"));
tileset->metatile_attrs_label = values.value(memberMap.key("metatileAttributes"));
} else {
// Read C tileset header
const QString path = projectConfig.getFilePath(ProjectFilePath::tilesets_headers);
auto structs = parser.readCStructs(path, label, memberMap);
if (!structs.contains(label)) {
logError(QString("Failed to find header data in '%1' for tileset '%2'.").arg(path).arg(label));
return nullptr;
}
if (tileset == nullptr) {
tileset = new Tileset;
}
auto tilesetAttributes = structs[label];
tileset->name = label;
tileset->is_secondary = ParseUtil::gameStringToBool(tilesetAttributes.value("isSecondary"));
tileset->tiles_label = tilesetAttributes.value("tiles");
tileset->palettes_label = tilesetAttributes.value("palettes");
tileset->metatiles_label = tilesetAttributes.value("metatiles");
tileset->metatile_attrs_label = tilesetAttributes.value("metatileAttributes");
}
if (!loadTilesetAssets(tileset)) {
// Error should already be logged.
delete tileset;
return nullptr;
}
tilesetCache.insert(label, tileset);
return tileset;
}
void Project::setNewLayoutBlockdata(Layout *layout) {
layout->blockdata.clear();
int width = layout->getWidth();
int height = layout->getHeight();
Block block(projectConfig.defaultMetatileId, projectConfig.defaultCollision, projectConfig.defaultElevation);
for (int i = 0; i < width * height; i++) {
layout->blockdata.append(block);
}
layout->lastCommitBlocks.blocks = layout->blockdata;
layout->lastCommitBlocks.layoutDimensions = QSize(width, height);
}
void Project::setNewLayoutBorder(Layout *layout) {
layout->border.clear();
int width = layout->getBorderWidth();
int height = layout->getBorderHeight();
if (projectConfig.newMapBorderMetatileIds.length() != width * height) {
// Border size doesn't match the number of default border metatiles.
// Fill the border with empty metatiles.
for (int i = 0; i < width * height; i++) {
layout->border.append(0);
}
} else {
// Fill the border with the default metatiles from the config.
for (int i = 0; i < width * height; i++) {
layout->border.append(projectConfig.newMapBorderMetatileIds.at(i));
}
}
layout->lastCommitBlocks.border = layout->border;
layout->lastCommitBlocks.borderDimensions = QSize(width, height);
}
bool Project::saveAll() {
bool success = true;
for (auto map : this->maps) {
if (!saveMap(map, true)) // Avoid double-saving the layouts
success = false;
}
for (auto layout : this->mapLayouts) {
if (!saveLayout(layout))
success = false;
}
if (!saveGlobalData()) success = false;
return success;
}
bool Project::saveMap(Map *map, bool skipLayout) {
if (!map || !isLoadedMap(map->name())) return true;
// Create/Modify a few collateral files for brand new maps.
const QString folderPath = projectConfig.getFilePath(ProjectFilePath::data_map_folders) + map->name();
const QString fullPath = QString("%1/%2").arg(this->root).arg(folderPath);
if (!map->isPersistedToFile()) {
if (!QDir::root().mkpath(fullPath)) {
logError(QString("Failed to create directory for new map: '%1'").arg(fullPath));
return false;
}
// Create file data/maps/<map_name>/scripts.inc
QString text = this->getScriptDefaultString(projectConfig.usePoryScript, map->name());
saveTextFile(fullPath + "/scripts" + this->getScriptFileExtension(projectConfig.usePoryScript), text);
if (projectConfig.createMapTextFileEnabled) {
// Create file data/maps/<map_name>/text.inc
saveTextFile(fullPath + "/text" + this->getScriptFileExtension(projectConfig.usePoryScript), "\n");
}
// Simply append to data/event_scripts.s.
text = QString("\n\t.include \"%1/scripts.inc\"\n").arg(folderPath);
if (projectConfig.createMapTextFileEnabled) {
text += QString("\t.include \"%1/text.inc\"\n").arg(folderPath);
}
appendTextFile(root + "/" + projectConfig.getFilePath(ProjectFilePath::data_event_scripts), text);
}
// Create map.json for map data.
QString mapFilepath = map->getJsonFilepath();
QFile mapFile(mapFilepath);
if (!mapFile.open(QIODevice::WriteOnly)) {
logError(QString("Could not open '%1' for writing: %2").arg(mapFilepath).arg(mapFile.errorString()));
return false;
}
OrderedJson::object mapObj;
// Header values.
mapObj["id"] = map->constantName();
mapObj["name"] = map->name();
mapObj["layout"] = map->layoutId();
mapObj["music"] = map->header()->song();
mapObj["region_map_section"] = map->header()->location();
mapObj["requires_flash"] = map->header()->requiresFlash();
mapObj["weather"] = map->header()->weather();
mapObj["map_type"] = map->header()->type();
if (projectConfig.mapAllowFlagsEnabled) {
mapObj["allow_cycling"] = map->header()->allowsBiking();
mapObj["allow_escaping"] = map->header()->allowsEscaping();
mapObj["allow_running"] = map->header()->allowsRunning();
}
mapObj["show_map_name"] = map->header()->showsLocationName();
if (projectConfig.floorNumberEnabled) {
mapObj["floor_number"] = map->header()->floorNumber();
}
mapObj["battle_scene"] = map->header()->battleScene();
// Connections
const auto connections = map->getConnections();
if (connections.length() > 0) {
OrderedJson::array connectionsArr;
for (const auto &connection : connections) {
OrderedJson::object connectionObj;
connectionObj["map"] = getMapConstant(connection->targetMapName(), connection->targetMapName());
connectionObj["offset"] = connection->offset();
connectionObj["direction"] = connection->direction();
OrderedJson::append(&connectionObj, connection->customData());
connectionsArr.append(connectionObj);
}
mapObj["connections"] = connectionsArr;
} else {
mapObj["connections"] = OrderedJson();
}
if (map->sharedEventsMap().isEmpty()) {
// Object events
OrderedJson::array objectEventsArr;
for (const auto &event : map->getEvents(Event::Group::Object)){
objectEventsArr.push_back(event->buildEventJson(this));
}
mapObj["object_events"] = objectEventsArr;
// Warp events
OrderedJson::array warpEventsArr;
for (const auto &event : map->getEvents(Event::Group::Warp)) {
warpEventsArr.push_back(event->buildEventJson(this));
}
mapObj["warp_events"] = warpEventsArr;
// Coord events
OrderedJson::array coordEventsArr;
for (const auto &event : map->getEvents(Event::Group::Coord)) {
coordEventsArr.push_back(event->buildEventJson(this));
}
mapObj["coord_events"] = coordEventsArr;
// Bg Events
OrderedJson::array bgEventsArr;
for (const auto &event : map->getEvents(Event::Group::Bg)) {
bgEventsArr.push_back(event->buildEventJson(this));
}
mapObj["bg_events"] = bgEventsArr;
} else {
mapObj["shared_events_map"] = map->sharedEventsMap();
}
if (!map->sharedScriptsMap().isEmpty()) {
mapObj["shared_scripts_map"] = map->sharedScriptsMap();
}
// Update the global heal locations array using the Map's heal location events.
// This won't get saved to disc until Project::saveHealLocations is called.
QList<HealLocationEvent*> hlEvents;
for (const auto &event : map->getEvents(Event::Group::Heal)) {
auto hl = static_cast<HealLocationEvent*>(event);
hlEvents.append(static_cast<HealLocationEvent*>(hl->duplicate()));
}
qDeleteAll(this->healLocations[map->constantName()]);
this->healLocations[map->constantName()] = hlEvents;
// Custom header fields.
OrderedJson::append(&mapObj, map->customAttributes());
ignoreWatchedFileTemporarily(mapFilepath);
OrderedJson mapJson(mapObj);
OrderedJsonDoc jsonDoc(&mapJson);
jsonDoc.dump(&mapFile);
mapFile.close();
// Try to record the MAPSEC name in case this is a new name.
addNewMapsec(map->header()->location());
map->setClean();
if (!skipLayout && !saveLayout(map->layout()))
return false;
return true;
}
bool Project::saveLayout(Layout *layout) {
if (!layout || !isLoadedLayout(layout->id))
return true;
if (!layout->save(this->root))
return false;
// Update global data structures with current map data.
if (!this->orderedLayoutIdsMaster.contains(layout->id)) {
this->orderedLayoutIdsMaster.append(layout->id);
}
if (this->mapLayoutsMaster.contains(layout->id)) {
this->mapLayoutsMaster[layout->id]->copyFrom(layout);
} else {
this->mapLayoutsMaster.insert(layout->id, layout->copy());
}
return true;
}
bool Project::saveGlobalData() {
bool success = true;
if (!saveMapLayouts()) success = false;
if (!saveMapGroups()) success = false;
if (!saveRegionMapSections()) success = false;
if (!saveHealLocations()) success = false;
if (!saveWildMonData()) success = false;
if (!saveConfig()) success = false;
if (!success)
return false;
this->hasUnsavedDataChanges = false;
return true;
}
bool Project::saveConfig() {
bool success = true;
if (!projectConfig.save()) success = false;
if (!userConfig.save()) success = false;
return success;
}
bool Project::loadTilesetAssets(Tileset* tileset) {
readTilesetPaths(tileset);
loadTilesetMetatileLabels(tileset);
return tileset->load();
}
void Project::readTilesetPaths(Tileset* tileset) {
// Parse the tileset data files to try and get explicit file paths for this tileset's assets
const QString rootDir = this->root + "/";
if (this->usingAsmTilesets) {
// Read asm tileset data files. Backwards compatibility
const QList<QStringList> graphics = parser.parseAsm(projectConfig.getFilePath(ProjectFilePath::tilesets_graphics_asm));
const QList<QStringList> metatiles_macros = parser.parseAsm(projectConfig.getFilePath(ProjectFilePath::tilesets_metatiles_asm));
const QStringList tiles_values = parser.getLabelValues(graphics, tileset->tiles_label);
const QStringList palettes_values = parser.getLabelValues(graphics, tileset->palettes_label);
const QStringList metatiles_values = parser.getLabelValues(metatiles_macros, tileset->metatiles_label);
const QStringList metatile_attrs_values = parser.getLabelValues(metatiles_macros, tileset->metatile_attrs_label);
if (!tiles_values.isEmpty())
tileset->tilesImagePath = this->fixGraphicPath(rootDir + tiles_values.value(0).section('"', 1, 1));
if (!metatiles_values.isEmpty())
tileset->metatiles_path = rootDir + metatiles_values.value(0).section('"', 1, 1);
if (!metatile_attrs_values.isEmpty())
tileset->metatile_attrs_path = rootDir + metatile_attrs_values.value(0).section('"', 1, 1);
for (const auto &value : palettes_values)
tileset->palettePaths.append(this->fixPalettePath(rootDir + value.section('"', 1, 1)));
} else {
// Read C tileset data files
const QString graphicsFile = projectConfig.getFilePath(ProjectFilePath::tilesets_graphics);
const QString metatilesFile = projectConfig.getFilePath(ProjectFilePath::tilesets_metatiles);
const QString tilesImagePath = parser.readCIncbin(graphicsFile, tileset->tiles_label);
const QStringList palettePaths = parser.readCIncbinArray(graphicsFile, tileset->palettes_label);
const QString metatilesPath = parser.readCIncbin(metatilesFile, tileset->metatiles_label);
const QString metatileAttrsPath = parser.readCIncbin(metatilesFile, tileset->metatile_attrs_label);
if (!tilesImagePath.isEmpty())
tileset->tilesImagePath = this->fixGraphicPath(rootDir + tilesImagePath);
if (!metatilesPath.isEmpty())
tileset->metatiles_path = rootDir + metatilesPath;
if (!metatileAttrsPath.isEmpty())
tileset->metatile_attrs_path = rootDir + metatileAttrsPath;
for (const auto &path : palettePaths)
tileset->palettePaths.append(this->fixPalettePath(rootDir + path));
}
// Try to set default paths, if any weren't found by reading the files above
QString defaultPath = rootDir + tileset->getExpectedDir();
if (tileset->tilesImagePath.isEmpty())
tileset->tilesImagePath = defaultPath + "/tiles.png";
if (tileset->metatiles_path.isEmpty())
tileset->metatiles_path = defaultPath + "/metatiles.bin";
if (tileset->metatile_attrs_path.isEmpty())
tileset->metatile_attrs_path = defaultPath + "/metatile_attributes.bin";
if (tileset->palettePaths.isEmpty()) {
QString palettes_dir_path = defaultPath + "/palettes/";
for (int i = 0; i < 16; i++) {
tileset->palettePaths.append(palettes_dir_path + QString("%1").arg(i, 2, 10, QLatin1Char('0')) + ".pal");
}
}
}
Tileset *Project::createNewTileset(QString name, bool secondary, bool checkerboardFill) {
const QString prefix = projectConfig.getIdentifier(ProjectIdentifier::symbol_tilesets_prefix);
if (!name.startsWith(prefix)) {
logError(QString("Tileset name '%1' doesn't begin with the prefix '%2'.").arg(name).arg(prefix));
return nullptr;
}
auto tileset = new Tileset();
tileset->name = name;
tileset->is_secondary = secondary;
// Create tileset directories
const QString fullDirectoryPath = QString("%1/%2").arg(this->root).arg(tileset->getExpectedDir());
QDir directory;
if (!directory.mkpath(fullDirectoryPath)) {
logError(QString("Failed to create directory '%1' for new tileset '%2'").arg(fullDirectoryPath).arg(tileset->name));
delete tileset;
return nullptr;
}
const QString palettesPath = fullDirectoryPath + "/palettes";
if (!directory.mkpath(palettesPath)) {
logError(QString("Failed to create palettes directory '%1' for new tileset '%2'").arg(palettesPath).arg(tileset->name));
delete tileset;
return nullptr;
}
tileset->tilesImagePath = fullDirectoryPath + "/tiles.png";
tileset->metatiles_path = fullDirectoryPath + "/metatiles.bin";
tileset->metatile_attrs_path = fullDirectoryPath + "/metatile_attributes.bin";
// Set default tiles image
QImage tilesImage(":/images/blank_tileset.png");
tileset->loadTilesImage(&tilesImage);
// Create default metatiles
const int numMetatiles = tileset->is_secondary ? (Project::getNumMetatilesTotal() - Project::getNumMetatilesPrimary()) : Project::getNumMetatilesPrimary();
const int tilesPerMetatile = projectConfig.getNumTilesInMetatile();
for (int i = 0; i < numMetatiles; ++i) {
auto metatile = new Metatile();
for(int j = 0; j < tilesPerMetatile; ++j){
Tile tile = Tile();
if (checkerboardFill) {
// Create a checkerboard-style dummy tileset
if (((i / 8) % 2) == 0)
tile.tileId = ((i % 2) == 0) ? 1 : 2;
else
tile.tileId = ((i % 2) == 1) ? 1 : 2;
if (tileset->is_secondary)
tile.tileId += Project::getNumTilesPrimary();
}
metatile->tiles.append(tile);
}
tileset->addMetatile(metatile);
}
// Create default palettes
for(int i = 0; i < 16; ++i) {
QList<QRgb> currentPal;
for(int i = 0; i < 16;++i) {
currentPal.append(qRgb(0,0,0));
}
tileset->palettes.append(currentPal);
tileset->palettePreviews.append(currentPal);
tileset->palettePaths.append(QString("%1/%2.pal").arg(palettesPath).arg(i, 2, 10, QLatin1Char('0')));
}
tileset->palettes[0][1] = qRgb(255,0,255);
tileset->palettePreviews[0][1] = qRgb(255,0,255);
// Update tileset label arrays
QStringList *labelList = tileset->is_secondary ? &this->secondaryTilesetLabels : &this->primaryTilesetLabels;
int i = 0;
for (; i < labelList->length(); i++) {
if (labelList->at(i) > tileset->name) {
break;
}
}
labelList->insert(i, tileset->name);
this->tilesetLabelsOrdered.append(tileset->name);
// Append to tileset specific files.
// TODO: Ideally we wouldn't save new Tilesets immediately
QString headersFilepath = this->root + "/";
QString graphicsFilepath = this->root + "/";
QString metatilesFilepath = this->root + "/";
if (this->usingAsmTilesets) {
headersFilepath.append(projectConfig.getFilePath(ProjectFilePath::tilesets_headers_asm));
graphicsFilepath.append(projectConfig.getFilePath(ProjectFilePath::tilesets_graphics_asm));
metatilesFilepath.append(projectConfig.getFilePath(ProjectFilePath::tilesets_metatiles_asm));
} else {
headersFilepath.append(projectConfig.getFilePath(ProjectFilePath::tilesets_headers));
graphicsFilepath.append(projectConfig.getFilePath(ProjectFilePath::tilesets_graphics));
metatilesFilepath.append(projectConfig.getFilePath(ProjectFilePath::tilesets_metatiles));
}
ignoreWatchedFilesTemporarily({headersFilepath, graphicsFilepath, metatilesFilepath});
name = Tileset::stripPrefix(name);
tileset->appendToHeaders(headersFilepath, name, this->usingAsmTilesets);
tileset->appendToGraphics(graphicsFilepath, name, this->usingAsmTilesets);
tileset->appendToMetatiles(metatilesFilepath, name, this->usingAsmTilesets);
tileset->save();
this->tilesetCache.insert(tileset->name, tileset);
emit tilesetCreated(tileset);
return tileset;
}
QString Project::findMetatileLabelsTileset(QString label) {
for (const QString &tilesetName : this->tilesetLabelsOrdered) {
QString metatileLabelPrefix = Tileset::getMetatileLabelPrefix(tilesetName);
if (label.startsWith(metatileLabelPrefix))
return tilesetName;
}
return QString();
}
bool Project::readTilesetMetatileLabels() {
metatileLabelsMap.clear();
unusedMetatileLabels.clear();
QString metatileLabelsFilename = projectConfig.getFilePath(ProjectFilePath::constants_metatile_labels);
watchFile(metatileLabelsFilename);
const QSet<QString> regexList = {QString("\\b%1").arg(projectConfig.getIdentifier(ProjectIdentifier::define_metatile_label_prefix))};
const auto defines = parser.readCDefinesByRegex(metatileLabelsFilename, regexList);
for (auto i = defines.constBegin(); i != defines.constEnd(); i++) {
QString label = i.key();
uint32_t metatileId = i.value();
if (metatileId > Block::maxValue) {
metatileId &= Block::maxValue;
logWarn(QString("Value of metatile label '%1' truncated to %2").arg(label).arg(Metatile::getMetatileIdString(metatileId)));
}
QString tilesetName = findMetatileLabelsTileset(label);
if (!tilesetName.isEmpty()) {
metatileLabelsMap[tilesetName][label] = metatileId;
} else {
// This #define name does not match any existing tileset.
// Save it separately to be outputted later.
unusedMetatileLabels[label] = metatileId;
}
}
return true;
}
void Project::loadTilesetMetatileLabels(Tileset* tileset) {
if (!tileset || tileset->name.isEmpty()) return;
QString metatileLabelPrefix = tileset->getMetatileLabelPrefix();
// Reverse map for faster lookup by metatile id
for (auto it = this->metatileLabelsMap[tileset->name].constBegin(); it != this->metatileLabelsMap[tileset->name].constEnd(); it++) {
QString labelName = it.key();
tileset->metatileLabels[it.value()] = labelName.replace(metatileLabelPrefix, "");
}
}
Tileset* Project::getTileset(QString label, bool forceLoad) {
Tileset *existingTileset = nullptr;
if (tilesetCache.contains(label)) {
existingTileset = tilesetCache.value(label);
}
if (existingTileset && !forceLoad) {
return existingTileset;
} else {
Tileset *tileset = loadTileset(label, existingTileset);
return tileset;
}
}
bool Project::saveTextFile(const QString &path, const QString &text) {
QFile file(path);
if (!file.open(QIODevice::WriteOnly)) {
logError(QString("Could not open '%1' for writing: ").arg(path) + file.errorString());
return false;
}
file.write(text.toUtf8());
return true;
}
bool Project::appendTextFile(const QString &path, const QString &text) {
QFile file(path);
if (!file.open(QIODevice::Append)) {
logError(QString("Could not open '%1' for appending: ").arg(path) + file.errorString());
return false;
}
file.write(text.toUtf8());
return true;
}
bool Project::readWildMonData() {
this->extraEncounterGroups.clear();
this->wildMonFields.clear();
this->wildMonData.clear();
this->wildMonTableName.clear();
this->encounterGroupLabels.clear();
this->pokemonMinLevel = 0;
this->pokemonMaxLevel = 100;
this->maxEncounterRate = 2880/16;
this->wildEncountersLoaded = false;
this->customWildMonData = OrderedJson::object();
this->customWildMonGroupData = OrderedJson::object();
if (!userConfig.useEncounterJson) {
return true;
}
// Read max encounter rate. The games multiply the encounter rate value in the map data by 16, so our input limit is the max/16.
const QString encounterRateFile = projectConfig.getFilePath(ProjectFilePath::wild_encounter);
const QString maxEncounterRateName = projectConfig.getIdentifier(ProjectIdentifier::define_max_encounter_rate);
watchFile(encounterRateFile);
auto defines = parser.readCDefinesByName(encounterRateFile, {maxEncounterRateName});
if (defines.contains(maxEncounterRateName))
this->maxEncounterRate = defines.value(maxEncounterRateName)/16;
// Read min/max level
const QString levelRangeFile = projectConfig.getFilePath(ProjectFilePath::constants_pokemon);
const QString minLevelName = projectConfig.getIdentifier(ProjectIdentifier::define_min_level);
const QString maxLevelName = projectConfig.getIdentifier(ProjectIdentifier::define_max_level);
watchFile(levelRangeFile);
defines = parser.readCDefinesByName(levelRangeFile, {minLevelName, maxLevelName});
if (defines.contains(minLevelName))
this->pokemonMinLevel = defines.value(minLevelName);
if (defines.contains(maxLevelName))
this->pokemonMaxLevel = defines.value(maxLevelName);
this->pokemonMinLevel = qMin(this->pokemonMinLevel, this->pokemonMaxLevel);
this->pokemonMaxLevel = qMax(this->pokemonMinLevel, this->pokemonMaxLevel);
// Read encounter data
const QString wildMonJsonFilepath = projectConfig.getFilePath(ProjectFilePath::json_wild_encounters);
watchFile(wildMonJsonFilepath);
OrderedJson::object wildMonObj;
QString error;
if (!parser.tryParseOrderedJsonFile(&wildMonObj, wildMonJsonFilepath, &error)) {
// Failing to read wild encounters data is not a critical error, the encounter editor will just be disabled
logWarn(QString("Failed to read wild encounters from '%1': %2").arg(wildMonJsonFilepath).arg(error));
return true;
}
// For each encounter type, count the number of times each encounter rate value occurs.
// The most common value will be used as the default for new groups.
QMap<QString, QMap<int, int>> encounterRateFrequencyMaps;
// Parse "wild_encounter_groups". This is the main object array containing all the data in this file.
OrderedJson::array mainArray = wildMonObj.take("wild_encounter_groups").array_items();
for (const OrderedJson &mainArrayJson : mainArray) {
OrderedJson::object mainArrayObject = mainArrayJson.object_items();
// We're only interested in wild encounter data that's associated with maps ("for_maps" == true).
// Any other wild encounter data (e.g. for Battle Pike / Battle Pyramid) will be ignored.
// We'll record any data that's not for maps in extraEncounterGroups to be outputted when we save.
if (!mainArrayObject["for_maps"].bool_value()) {
this->extraEncounterGroups.push_back(mainArrayObject);
continue;
} else {
// Note: We don't call 'take' above, we don't want to strip data from extraEncounterGroups.
// We do want to strip it from the main group, because it shouldn't be treated as custom data.
mainArrayObject.erase("for_maps");
}
// If multiple "for_maps" data sets are found they will be collapsed into a single set.
QString label = mainArrayObject.take("label").string_value();
if (this->wildMonTableName.isEmpty()) {
this->wildMonTableName = label;
} else {
logWarn(QString("Wild encounters table '%1' will be combined with '%2'. Only one table with \"for_maps\" set to 'true' is expected.")
.arg(label)
.arg(this->wildMonTableName));
}
// Parse the "fields" data. This is like the header for the wild encounters data.
// Each element describes a type of wild encounter Porymap can expect to find, and we represent this data with an EncounterField.
// They should contain a name ("type"), the number of encounter slots and the ratio at which they occur ("encounter_rates"),
// and whether the encounters are divided into groups (like fishing rods).
OrderedJson::array fieldsArray = mainArrayObject.take("fields").array_items();
for (const OrderedJson &fieldJson : fieldsArray) {
OrderedJson::object fieldObject = fieldJson.object_items();
EncounterField encounterField;
encounterField.name = fieldObject.take("type").string_value();
OrderedJson::array encounterRatesArray = fieldObject.take("encounter_rates").array_items();
for (const auto &val : encounterRatesArray) {
encounterField.encounterRates.append(val.int_value());
}
// Each element of the "groups" array is an object with the group name as the key (e.g. "old_rod")
// and an array of slot numbers indicating which encounter slots in this encounter type belong to that group.
OrderedJson::object groups = fieldObject.take("groups").object_items();
for (auto groupPair : groups) {
const QString groupName = groupPair.first;
for (auto slotNum : groupPair.second.array_items()) {
encounterField.groups[groupName].append(slotNum.int_value());
}
}
encounterField.customData = fieldObject;
encounterRateFrequencyMaps.insert(encounterField.name, QMap<int, int>());
this->wildMonFields.append(encounterField);
}
// Parse the "encounters" data. This is the meat of the wild encounters data.
// Each element is an object that will tell us which map it's associated with,
// its symbol name (which we will display in the Groups dropdown) and a list of
// pokémon associated with any of the encounter types described by the data we parsed above.
OrderedJson::array encountersArray = mainArrayObject.take("encounters").array_items();
for (const auto &encounterJson : encountersArray) {
OrderedJson::object encounterObj = encounterJson.object_items();
WildPokemonHeader header;
// Check for each possible encounter type.
for (const EncounterField &monField : this->wildMonFields) {
const QString field = monField.name;
if (!encounterObj.contains(field)) {
// Encounter type isn't present
continue;
}
OrderedJson::object encounterFieldObj = encounterObj.take(field).object_items();
WildMonInfo monInfo;
monInfo.active = true;
// Read encounter rate
monInfo.encounterRate = encounterFieldObj.take("encounter_rate").int_value();
encounterRateFrequencyMaps[field][monInfo.encounterRate]++;
// Read wild pokémon list
OrderedJson::array monsArray = encounterFieldObj.take("mons").array_items();
for (const auto &monJson : monsArray) {
OrderedJson::object monObj = monJson.object_items();
WildPokemon newMon;
newMon.minLevel = monObj.take("min_level").int_value();
newMon.maxLevel = monObj.take("max_level").int_value();
newMon.species = monObj.take("species").string_value();
newMon.customData = monObj;
monInfo.wildPokemon.append(newMon);
}
monInfo.customData = encounterFieldObj;
// If the user supplied too few pokémon for this group then we fill in the rest with default values.
for (int i = monInfo.wildPokemon.length(); i < monField.encounterRates.length(); i++) {
monInfo.wildPokemon.append(WildPokemon());
}
header.wildMons[field] = monInfo;
}
const QString mapConstant = encounterObj.take("map").string_value();
const QString baseLabel = encounterObj.take("base_label").string_value();
header.customData = encounterObj;
this->wildMonData[mapConstant].insert({baseLabel, header});
this->encounterGroupLabels.append(baseLabel);
}
this->customWildMonGroupData = mainArrayObject;
}
this->customWildMonData = wildMonObj;
// For each encounter type, set default encounter rate to most common value.
// Iterate over map of encounter type names to frequency maps...
for (auto i = encounterRateFrequencyMaps.cbegin(), i_end = encounterRateFrequencyMaps.cend(); i != i_end; i++) {
int frequency = 0;
int rate = 1;
const QMap<int, int> frequencyMap = i.value();
// Iterate over frequency map (encounter rate to number of occurrences)...
for (auto j = frequencyMap.cbegin(), j_end = frequencyMap.cend(); j != j_end; j++) {
if (j.value() > frequency) {
frequency = j.value();
rate = j.key();
}
}
setDefaultEncounterRate(i.key(), rate);
}
this->wildEncountersLoaded = true;
return true;
}
bool Project::readMapGroups() {
clearMaps();
this->mapConstantsToMapNames.clear();
this->alphabeticalMapNames.clear();
this->groupNames.clear();
this->groupNameToMapNames.clear();
this->customMapGroupsData = QJsonObject();
const QString filepath = projectConfig.getFilePath(ProjectFilePath::json_map_groups);
watchFile(filepath);
QJsonDocument mapGroupsDoc;
QString error;
if (!parser.tryParseJsonFile(&mapGroupsDoc, filepath, &error)) {
logError(QString("Failed to read map groups from '%1': %2").arg(filepath).arg(error));
return false;
}
QJsonObject mapGroupsObj = mapGroupsDoc.object();
QJsonArray mapGroupOrder = mapGroupsObj.take("group_order").toArray();
const QString dynamicMapName = getDynamicMapName();
const QString dynamicMapConstant = getDynamicMapDefineName();
// Process the map group lists
for (int groupIndex = 0; groupIndex < mapGroupOrder.size(); groupIndex++) {
const QString groupName = ParseUtil::jsonToQString(mapGroupOrder.at(groupIndex));
if (this->groupNames.contains(groupName)) {
logWarn(QString("Ignoring repeated map group name '%1'.").arg(groupName));
continue;
}
const QJsonArray mapNamesJson = mapGroupsObj.take(groupName).toArray();
this->groupNames.append(groupName);
// Process the names in this map group
for (int j = 0; j < mapNamesJson.size(); j++) {
const QString mapName = ParseUtil::jsonToQString(mapNamesJson.at(j));
if (mapName.isEmpty()) {
logWarn(QString("Ignoring empty map %1 in map group '%2'.").arg(j).arg(groupName).arg(mapName));
continue;
}
// We explicitly hide "Dynamic" from the map list, so this entry will be deleted from the file if the user changes the map list order.
if (mapName == dynamicMapName) {
logWarn(QString("Ignoring map %1 in map group '%2': Cannot use reserved map name '%3'.").arg(j).arg(groupName).arg(mapName));
continue;
}
// Excepting the disallowed map names above, we want to preserve the user's map list data,
// so this list should accept all names we find whether they have valid data or not.
this->groupNameToMapNames[groupName].append(mapName);
// We log a warning for this, but a repeated name in the map list otherwise functions fine.
// All repeated entries will refer to the same map data.
if (this->maps.contains(mapName)) {
logWarn(QString("Map %1 in map group '%2' has repeated map name '%3'.").arg(j).arg(groupName).arg(mapName));
continue;
}
// Load the map's json file so we can get its ID constant (and two other constants we use for the map list).
// If we fail to get the ID for any reason, we flag the map as 'errored'. It can still appear in the map list,
// but we won't be able to translate the map name to a map constant, so the map name can't appear elsewhere.
QString mapJsonError;
QJsonDocument mapDoc = readMapJson(mapName, &mapJsonError);
if (!mapJsonError.isEmpty()) {
this->erroredMaps.insert(mapName, mapJsonError);
logWarn(mapJsonError);
continue;
}
// Read and validate the map's ID from its JSON data.
const QJsonObject mapObj = mapDoc.object();
const QString mapConstant = ParseUtil::jsonToQString(mapObj["id"]);
if (mapConstant.isEmpty()) {
QString message = QString("Map '%1' is invalid: Missing \"id\" value.").arg(mapName);
this->erroredMaps.insert(mapName, message);
logWarn(message);
continue;
}
if (mapConstant == dynamicMapConstant) {
QString message = QString("Map '%1' is invalid: Cannot use reserved name '%2' for \"id\" value.").arg(mapName).arg(mapConstant);
this->erroredMaps.insert(mapName, message);
logWarn(message);
continue;
}
auto it = this->mapConstantsToMapNames.constFind(mapConstant);
if (it != this->mapConstantsToMapNames.constEnd()) {
QString message = QString("Map '%1' is invalid: Cannot use the same \"id\" value '%2' as map '%3'.")
.arg(mapName)
.arg(it.key())
.arg(it.value());
this->erroredMaps.insert(mapName, message);
logWarn(message);
continue;
}
// Success, create the Map object
auto map = new Map;
map->setName(mapName);
map->setConstantName(mapConstant);
this->maps.insert(mapName, map);
this->alphabeticalMapNames.append(mapName);
this->mapConstantsToMapNames.insert(mapConstant, mapName);
// Read layout ID for map list
const QString layoutId = ParseUtil::jsonToQString(mapObj["layout"]);
map->setLayoutId(layoutId);
map->setLayout(this->mapLayouts.value(layoutId)); // This may set layout to nullptr. Don't report anything until user tries to load this map.
// Read MAPSEC name for map list
map->header()->setLocation(ParseUtil::jsonToQString(mapObj["region_map_section"]));
}
}
// Note: Not successfully reading any maps or map groups is ok. We only require at least 1 map layout.
// Save special "Dynamic" constant
this->mapConstantsToMapNames.insert(dynamicMapConstant, dynamicMapName);
this->alphabeticalMapNames.append(dynamicMapName);
Util::numericalModeSort(this->alphabeticalMapNames);
// Chuck the "connections_include_order" field, this is only for matching.
if (!projectConfig.preserveMatchingOnlyData) {
mapGroupsObj.remove("connections_include_order");
}
// Preserve any remaining fields for when we save.
this->customMapGroupsData = mapGroupsObj;
return true;
}
void Project::addNewMapGroup(const QString &groupName) {
if (this->groupNames.contains(groupName))
return;
this->groupNames.append(groupName);
this->groupNameToMapNames.insert(groupName, QStringList());
this->hasUnsavedDataChanges = true;
emit mapGroupAdded(groupName);
}
QString Project::mapNameToMapGroup(const QString &mapName) const {
for (auto it = this->groupNameToMapNames.constBegin(); it != this->groupNameToMapNames.constEnd(); it++) {
if (it.value().contains(mapName)) {
return it.key();
}
}
return QString();
}
QString Project::getMapConstant(const QString &mapName, const QString &defaultValue) const {
if (mapName == getDynamicMapName()) return getDynamicMapDefineName();
Map* map = this->maps.value(mapName);
return map ? map->constantName() : defaultValue;
}
QString Project::getMapLayoutId(const QString &mapName, const QString &defaultValue) const {
Map* map = this->maps.value(mapName);
return map ? map->layoutId() : defaultValue;
}
QString Project::getMapLocation(const QString &mapName, const QString &defaultValue) const {
Map* map = this->maps.value(mapName);
return map ? map->header()->location() : defaultValue;
}
QString Project::getLayoutName(const QString &layoutId) const {
Layout* layout = this->mapLayouts.value(layoutId);
return layout ? layout->name : QString();
}
QStringList Project::getLayoutNames() const {
QStringList names;
for (const auto &layoutId : this->alphabeticalLayoutIds) {
names.append(getLayoutName(layoutId));
}
return names;
}
QStringList Project::getMapNamesByGroup() const {
QStringList names;
for (const auto &groupName : this->groupNames) {
for (const auto &groupMapNames : this->groupNameToMapNames.value(groupName)) {
names.append(groupMapNames);
}
}
return names;
}
bool Project::isUnsavedMap(const QString &mapName) const {
Map* map = this->maps.value(mapName);
return map ? map->hasUnsavedChanges() : false;
}
bool Project::isUnsavedLayout(const QString &layoutId) const {
Layout* layout = this->mapLayouts.value(layoutId);
return layout ? layout->hasUnsavedChanges() : false;
}
// Determining which map a secret base ID refers to relies on assumptions about its name.
// The default format is for a secret base ID of 'SECRET_BASE_FOO_#' to refer to a map with the constant
// 'MAP_SECRET_BASE_FOO', so we strip the `_#` suffix and add the default map prefix 'MAP_'. If this fails,
// we'll try every combination of that prefix, suffix, and 'SECRET_BASE_FOO'.
QString Project::secretBaseIdToMapName(const QString &secretBaseId) const {
const QString mapPrefix = projectConfig.getIdentifier(ProjectIdentifier::define_map_prefix);
QString baseIdNoSuffix = secretBaseId.left(secretBaseId.lastIndexOf("_"));
auto it = this->mapConstantsToMapNames.constFind(mapPrefix + baseIdNoSuffix);
if (it != this->mapConstantsToMapNames.constEnd()) {
// Found a result of the format 'SECRET_BASE_FOO_#' -> 'MAP_SECRET_BASE_FOO'.
return it.value();
}
it = this->mapConstantsToMapNames.constFind(baseIdNoSuffix);
if (it != this->mapConstantsToMapNames.constEnd()) {
// Found a result of the format 'SECRET_BASE_FOO_#' -> 'SECRET_BASE_FOO'.
return it.value();
}
it = this->mapConstantsToMapNames.constFind(mapPrefix + secretBaseId);
if (it != this->mapConstantsToMapNames.constEnd()) {
// Found a result of the format 'SECRET_BASE_FOO_#' -> 'MAP_SECRET_BASE_FOO_#'.
return it.value();
}
it = this->mapConstantsToMapNames.constFind(secretBaseId);
if (it != this->mapConstantsToMapNames.constEnd()) {
// 'SECRET_BASE_FOO_#' is already a map constant.
return it.value();
}
return QString();
}
// When we ask the user to provide a new identifier for something (like a map name or MAPSEC id)
// we use this to make sure that it doesn't collide with any known identifiers first.
// Porymap knows of many more identifiers than this, but for simplicity we only check the lists that users can add to via Porymap.
// In general this only matters to Porymap if the identifier will be added to the group it collides with,
// but name collisions are likely undesirable in the project.
bool Project::isIdentifierUnique(const QString &identifier) const {
if (this->maps.contains(identifier) || this->erroredMaps.contains(identifier))
return false;
if (this->mapConstantsToMapNames.contains(identifier))
return false;
if (this->groupNames.contains(identifier))
return false;
if (this->mapSectionIdNames.contains(identifier))
return false;
if (this->tilesetLabelsOrdered.contains(identifier))
return false;
if (this->mapLayouts.contains(identifier))
return false;
for (const auto &layout : this->mapLayouts) {
if (layout->name == identifier) {
return false;
}
}
if (identifier == getEmptyMapDefineName())
return false;
if (this->encounterGroupLabels.contains(identifier))
return false;
// Check event IDs
for (const auto &mapName : this->loadedMapNames) {
for (const auto &event : this->maps.value(mapName)->getEvents()) {
QString idName = event->getIdName();
if (!idName.isEmpty() && idName == identifier)
return false;
}
}
return true;
}
// For some arbitrary string, return true if it's both a valid identifier name and not one that's already in-use.
bool Project::isValidNewIdentifier(const QString &identifier) const {
static const IdentifierValidator validator;
return validator.isValid(identifier) && isIdentifierUnique(identifier);
}
// Assumes 'identifier' is a valid name. If 'identifier' is unique, returns 'identifier'.
// Otherwise returns the identifier with a numbered suffix added to make it unique.
QString Project::toUniqueIdentifier(const QString &identifier) const {
int suffix = 2;
QString uniqueIdentifier = identifier;
while (!isIdentifierUnique(uniqueIdentifier)) {
uniqueIdentifier = QString("%1_%2").arg(identifier).arg(suffix++);
}
return uniqueIdentifier;
}
void Project::initNewMapSettings() {
this->newMapSettings.name = QString();
this->newMapSettings.group = this->groupNames.value(0);
this->newMapSettings.canFlyTo = false;
this->newMapSettings.layout.folderName = this->newMapSettings.name;
this->newMapSettings.layout.name = QString();
this->newMapSettings.layout.id = Layout::layoutConstantFromName(this->newMapSettings.name);
this->newMapSettings.layout.width = this->defaultMapSize.width();
this->newMapSettings.layout.height = this->defaultMapSize.height();
this->newMapSettings.layout.borderWidth = DEFAULT_BORDER_WIDTH;
this->newMapSettings.layout.borderHeight = DEFAULT_BORDER_HEIGHT;
this->newMapSettings.layout.primaryTilesetLabel = getDefaultPrimaryTilesetLabel();
this->newMapSettings.layout.secondaryTilesetLabel = getDefaultSecondaryTilesetLabel();
this->newMapSettings.header.setSong(this->defaultSong);
this->newMapSettings.header.setLocation(this->mapSectionIdNames.value(0, "0"));
this->newMapSettings.header.setRequiresFlash(false);
this->newMapSettings.header.setWeather(this->weatherNames.value(0, "0"));
this->newMapSettings.header.setType(this->mapTypes.value(0, "0"));
this->newMapSettings.header.setBattleScene(this->mapBattleScenes.value(0, "0"));
this->newMapSettings.header.setShowsLocationName(true);
this->newMapSettings.header.setAllowsRunning(false);
this->newMapSettings.header.setAllowsBiking(false);
this->newMapSettings.header.setAllowsEscaping(false);
this->newMapSettings.header.setFloorNumber(0);
}
void Project::initNewLayoutSettings() {
this->newLayoutSettings.name = QString();
this->newLayoutSettings.id = Layout::layoutConstantFromName(this->newLayoutSettings.name);
this->newLayoutSettings.width = this->defaultMapSize.width();
this->newLayoutSettings.height = this->defaultMapSize.height();
this->newLayoutSettings.borderWidth = DEFAULT_BORDER_WIDTH;
this->newLayoutSettings.borderHeight = DEFAULT_BORDER_HEIGHT;
this->newLayoutSettings.primaryTilesetLabel = getDefaultPrimaryTilesetLabel();
this->newLayoutSettings.secondaryTilesetLabel = getDefaultSecondaryTilesetLabel();
}
QString Project::getDefaultPrimaryTilesetLabel() const {
QString defaultLabel = projectConfig.defaultPrimaryTileset;
if (!this->primaryTilesetLabels.contains(defaultLabel)) {
QString firstLabel = this->primaryTilesetLabels.first();
logWarn(QString("Unable to find default primary tileset '%1', using '%2' instead.").arg(defaultLabel).arg(firstLabel));
defaultLabel = firstLabel;
}
return defaultLabel;
}
QString Project::getDefaultSecondaryTilesetLabel() const {
QString defaultLabel = projectConfig.defaultSecondaryTileset;
if (!this->secondaryTilesetLabels.contains(defaultLabel)) {
QString firstLabel = this->secondaryTilesetLabels.first();
logWarn(QString("Unable to find default secondary tileset '%1', using '%2' instead.").arg(defaultLabel).arg(firstLabel));
defaultLabel = firstLabel;
}
return defaultLabel;
}
void Project::appendTilesetLabel(const QString &label, const QString &isSecondaryStr) {
bool ok;
bool isSecondary = ParseUtil::gameStringToBool(isSecondaryStr, &ok);
if (!ok) {
logError(QString("Unable to convert value '%1' of isSecondary to bool for tileset %2.").arg(isSecondaryStr).arg(label));
return;
}
QStringList * list = isSecondary ? &this->secondaryTilesetLabels : &this->primaryTilesetLabels;
list->append(label);
this->tilesetLabelsOrdered.append(label);
}
bool Project::readTilesetLabels() {
this->primaryTilesetLabels.clear();
this->secondaryTilesetLabels.clear();
this->tilesetLabelsOrdered.clear();
QString filename = projectConfig.getFilePath(ProjectFilePath::tilesets_headers);
QFileInfo fileInfo(this->root + "/" + filename);
if (!fileInfo.exists() || !fileInfo.isFile()) {
// If the tileset headers file is missing, the user may still have the old assembly format.
this->usingAsmTilesets = true;
QString asm_filename = projectConfig.getFilePath(ProjectFilePath::tilesets_headers_asm);
QString text = parser.loadTextFile(asm_filename);
if (text.isEmpty()) {
logError(QString("Failed to read tileset labels from '%1' or '%2'.").arg(filename).arg(asm_filename));
return false;
}
static const QRegularExpression re("(?<label>[A-Za-z0-9_]*):{1,2}[A-Za-z0-9_@ ]*\\s+.+\\s+\\.byte\\s+(?<isSecondary>[A-Za-z0-9_]+)");
QRegularExpressionMatchIterator iter = re.globalMatch(text);
while (iter.hasNext()) {
QRegularExpressionMatch match = iter.next();
appendTilesetLabel(match.captured("label"), match.captured("isSecondary"));
}
filename = asm_filename; // For error reporting further down
} else {
this->usingAsmTilesets = false;
const auto structs = parser.readCStructs(filename, "", Tileset::getHeaderMemberMap(this->usingAsmTilesets));
for (auto i = structs.cbegin(); i != structs.cend(); i++){
appendTilesetLabel(i.key(), i.value().value("isSecondary"));
}
}
Util::numericalModeSort(this->primaryTilesetLabels);
Util::numericalModeSort(this->secondaryTilesetLabels);
bool success = true;
if (this->secondaryTilesetLabels.isEmpty()) {
logError(QString("Failed to find any secondary tilesets in %1").arg(filename));
success = false;
}
if (this->primaryTilesetLabels.isEmpty()) {
logError(QString("Failed to find any primary tilesets in %1").arg(filename));
success = false;
}
return success;
}
bool Project::readFieldmapProperties() {
const QString numTilesPrimaryName = projectConfig.getIdentifier(ProjectIdentifier::define_tiles_primary);
const QString numTilesTotalName = projectConfig.getIdentifier(ProjectIdentifier::define_tiles_total);
const QString numMetatilesPrimaryName = projectConfig.getIdentifier(ProjectIdentifier::define_metatiles_primary);
const QString numPalsPrimaryName = projectConfig.getIdentifier(ProjectIdentifier::define_pals_primary);
const QString numPalsTotalName = projectConfig.getIdentifier(ProjectIdentifier::define_pals_total);
const QString maxMapSizeName = projectConfig.getIdentifier(ProjectIdentifier::define_map_size);
const QString numTilesPerMetatileName = projectConfig.getIdentifier(ProjectIdentifier::define_tiles_per_metatile);
const QString mapOffsetWidthName = projectConfig.getIdentifier(ProjectIdentifier::define_map_offset_width);
const QString mapOffsetHeightName = projectConfig.getIdentifier(ProjectIdentifier::define_map_offset_height);
const QString filename = projectConfig.getFilePath(ProjectFilePath::constants_fieldmap);
watchFile(filename);
const auto defines = parser.readCDefinesByName(filename, { numTilesPrimaryName,
numTilesTotalName,
numMetatilesPrimaryName,
numPalsPrimaryName,
numPalsTotalName,
maxMapSizeName,
numTilesPerMetatileName,
mapOffsetWidthName,
mapOffsetHeightName,
});
auto loadDefine = [defines](const QString name, int * dest, int min, int max) {
auto it = defines.find(name);
if (it != defines.end()) {
*dest = it.value();
if (*dest < min) {
logWarn(QString("Value for '%1' (%2) is below the minimum (%3). Defaulting to minimum.").arg(name).arg(*dest).arg(min));
*dest = min;
} else if (*dest > max) {
logWarn(QString("Value for '%1' (%2) is above the maximum (%3). Defaulting to maximum.").arg(name).arg(*dest).arg(max));
*dest = max;
}
} else {
logWarn(QString("Value for '%1' not found. Using default (%2) instead.").arg(name).arg(*dest));
}
};
loadDefine(numPalsTotalName, &Project::num_pals_total, 2, INT_MAX); // In reality the max would be 16, but as far as Porymap is concerned it doesn't matter.
loadDefine(numTilesTotalName, &Project::num_tiles_total, 2, 1024); // 1024 is fixed because we store tile IDs in a 10-bit field.
loadDefine(numPalsPrimaryName, &Project::num_pals_primary, 1, Project::num_pals_total - 1);
loadDefine(numTilesPrimaryName, &Project::num_tiles_primary, 1, Project::num_tiles_total - 1);
// This maximum is overly generous, because until we parse the appropriate masks from the project
// we don't actually know what the maximum number of metatiles is.
loadDefine(numMetatilesPrimaryName, &Project::num_metatiles_primary, 1, 0xFFFF - 1);
int w = 15, h = 14; // Default values of MAP_OFFSET_W, MAP_OFFSET_H
loadDefine(mapOffsetWidthName, &w, 0, INT_MAX);
loadDefine(mapOffsetHeightName, &h, 0, INT_MAX);
this->mapSizeAddition = QSize(w, h);
this->maxMapDataSize = 10240; // Default value of MAX_MAP_DATA_SIZE
this->defaultMapSize = projectConfig.defaultMapSize;
auto it = defines.find(maxMapSizeName);
if (it != defines.end()) {
int min = getMapDataSize(1, 1);
if (it.value() >= min) {
this->maxMapDataSize = it.value();
if (getMapDataSize(this->defaultMapSize.width(), this->defaultMapSize.height()) > this->maxMapDataSize) {
// The specified map size is too small to use the default map dimensions.
// Calculate the largest square map size that we can use instead.
int dimension = qFloor((qSqrt(4 * this->maxMapDataSize + 1) - (w + h)) / 2);
logWarn(QString("Value for '%1' (%2) is too small to support the default %3x%4 map. Default changed to %5x%5.")
.arg(maxMapSizeName)
.arg(it.value())
.arg(this->defaultMapSize.width())
.arg(this->defaultMapSize.height())
.arg(dimension));
this->defaultMapSize = QSize(dimension, dimension);
}
} else {
logWarn(QString("Value for '%1' (%2) is too small to support a 1x1 map. Must be at least %3. Using default (%4) instead.")
.arg(maxMapSizeName)
.arg(it.value())
.arg(min)
.arg(this->maxMapDataSize));
}
}
else {
logWarn(QString("Value for '%1' not found. Using default (%2) instead.")
.arg(maxMapSizeName)
.arg(this->maxMapDataSize));
}
it = defines.find(numTilesPerMetatileName);
if (it != defines.end()) {
// We can determine whether triple-layer metatiles are in-use by reading this constant.
// If the constant is missing (or is using a value other than 8 or 12) the user must tell
// us whether they're using triple-layer metatiles under Project Settings.
int numTilesPerMetatile = it.value();
if (numTilesPerMetatile == 2 * Metatile::tilesPerLayer()) {
projectConfig.tripleLayerMetatilesEnabled = false;
this->disabledSettingsNames.insert(numTilesPerMetatileName);
} else if (numTilesPerMetatile == 3 * Metatile::tilesPerLayer()) {
projectConfig.tripleLayerMetatilesEnabled = true;
this->disabledSettingsNames.insert(numTilesPerMetatileName);
}
}
return true;
}
// Read data masks for Blocks and metatile attributes.
bool Project::readFieldmapMasks() {
this->encounterTypeToName.clear();
this->terrainTypeToName.clear();
const QString metatileIdMaskName = projectConfig.getIdentifier(ProjectIdentifier::define_mask_metatile);
const QString collisionMaskName = projectConfig.getIdentifier(ProjectIdentifier::define_mask_collision);
const QString elevationMaskName = projectConfig.getIdentifier(ProjectIdentifier::define_mask_elevation);
const QString behaviorMaskName = projectConfig.getIdentifier(ProjectIdentifier::define_mask_behavior);
const QString layerTypeMaskName = projectConfig.getIdentifier(ProjectIdentifier::define_mask_layer);
const QString globalFieldmap = projectConfig.getFilePath(ProjectFilePath::global_fieldmap); // File already being watched
const auto defines = parser.readCDefinesByName(globalFieldmap, { metatileIdMaskName,
collisionMaskName,
elevationMaskName,
behaviorMaskName,
layerTypeMaskName,
});
// These mask values are accessible via the settings editor for users who don't have these defines.
// If users do have the defines we disable them in the settings editor and direct them to their project files.
// Record the names we read so we know later which settings to disable.
const QStringList defineNames = defines.keys();
for (auto name : defineNames)
this->disabledSettingsNames.insert(name);
// Read Block masks
auto readBlockMask = [defines](const QString name, uint16_t *value) {
auto it = defines.constFind(name);
if (it == defines.constEnd())
return false;
*value = static_cast<uint16_t>(it.value());
if (*value != it.value()){
logWarn(QString("Value for %1 truncated from '%2' to '%3'")
.arg(name)
.arg(Util::toHexString(it.value()))
.arg(Util::toHexString(*value)));
}
return true;
};
uint16_t blockMask;
if (readBlockMask(metatileIdMaskName, &blockMask))
projectConfig.blockMetatileIdMask = blockMask;
if (readBlockMask(collisionMaskName, &blockMask))
projectConfig.blockCollisionMask = blockMask;
if (readBlockMask(elevationMaskName, &blockMask))
projectConfig.blockElevationMask = blockMask;
Block::setLayout();
// Read RSE metatile attribute masks
auto it = defines.find(behaviorMaskName);
if (it != defines.end())
projectConfig.metatileBehaviorMask = static_cast<uint32_t>(it.value());
it = defines.find(layerTypeMaskName);
if (it != defines.end())
projectConfig.metatileLayerTypeMask = static_cast<uint32_t>(it.value());
// pokefirered keeps its attribute masks in a separate table, parse this too.
const QString attrTableName = projectConfig.getIdentifier(ProjectIdentifier::symbol_attribute_table);
const QString srcFieldmap = projectConfig.getFilePath(ProjectFilePath::fieldmap);
const QMap<QString, QString> attrTable = parser.readNamedIndexCArray(srcFieldmap, attrTableName);
if (!attrTable.isEmpty()) {
const QString behaviorTableName = projectConfig.getIdentifier(ProjectIdentifier::define_attribute_behavior);
const QString layerTypeTableName = projectConfig.getIdentifier(ProjectIdentifier::define_attribute_layer);
const QString encounterTypeTableName = projectConfig.getIdentifier(ProjectIdentifier::define_attribute_encounter);
const QString terrainTypeTableName = projectConfig.getIdentifier(ProjectIdentifier::define_attribute_terrain);
watchFile(srcFieldmap);
bool ok;
// Read terrain type mask
uint32_t mask = attrTable.value(terrainTypeTableName).toUInt(&ok, 0);
if (ok) {
projectConfig.metatileTerrainTypeMask = mask;
this->disabledSettingsNames.insert(terrainTypeTableName);
}
// Read encounter type mask
mask = attrTable.value(encounterTypeTableName).toUInt(&ok, 0);
if (ok) {
projectConfig.metatileEncounterTypeMask = mask;
this->disabledSettingsNames.insert(encounterTypeTableName);
}
// If we haven't already parsed behavior and layer type then try those too
if (!this->disabledSettingsNames.contains(behaviorMaskName)) {
// Read behavior mask
mask = attrTable.value(behaviorTableName).toUInt(&ok, 0);
if (ok) {
projectConfig.metatileBehaviorMask = mask;
this->disabledSettingsNames.insert(behaviorTableName);
}
}
if (!this->disabledSettingsNames.contains(layerTypeMaskName)) {
// Read layer type mask
mask = attrTable.value(layerTypeTableName).toUInt(&ok, 0);
if (ok) {
projectConfig.metatileLayerTypeMask = mask;
this->disabledSettingsNames.insert(layerTypeTableName);
}
}
}
// Read #defines for encounter and terrain types to populate in the Tileset Editor dropdowns (if necessary)
QString error;
if (projectConfig.metatileEncounterTypeMask) {
const auto defines = parser.readCDefinesByRegex(globalFieldmap, {projectConfig.getIdentifier(ProjectIdentifier::regex_encounter_types)}, &error);
if (!error.isEmpty()) {
logWarn(QString("Failed to read encounter type constants from '%1': %2").arg(globalFieldmap).arg(error));
error = QString();
} else {
for (auto i = defines.constBegin(); i != defines.constEnd(); i++) {
this->encounterTypeToName.insert(static_cast<uint32_t>(i.value()), i.key());
}
}
}
if (projectConfig.metatileTerrainTypeMask) {
const auto defines = parser.readCDefinesByRegex(globalFieldmap, {projectConfig.getIdentifier(ProjectIdentifier::regex_terrain_types)}, &error);
if (!error.isEmpty()) {
logWarn(QString("Failed to read terrain type constants from '%1': %2").arg(globalFieldmap).arg(error));
error = QString();
} else {
for (auto i = defines.constBegin(); i != defines.constEnd(); i++) {
this->terrainTypeToName.insert(static_cast<uint32_t>(i.value()), i.key());
}
}
}
return true;
}
bool Project::readRegionMapSections() {
this->locationData.clear();
this->mapSectionIdNames.clear();
this->mapSectionIdNamesSaveOrder.clear();
this->customMapSectionsData = QJsonObject();
const QString defaultName = getEmptyMapsecName();
const QString requiredPrefix = projectConfig.getIdentifier(ProjectIdentifier::define_map_section_prefix);
QJsonDocument doc;
const QString filepath = projectConfig.getFilePath(ProjectFilePath::json_region_map_entries);
QString error;
if (!parser.tryParseJsonFile(&doc, filepath, &error)) {
logError(QString("Failed to read region map sections from '%1': %2").arg(filepath).arg(error));
return false;
}
watchFile(filepath);
QJsonObject mapSectionsGlobalObj = doc.object();
QJsonArray mapSections = mapSectionsGlobalObj.take("map_sections").toArray();
for (int i = 0; i < mapSections.size(); i++) {
QJsonObject mapSectionObj = mapSections.at(i).toObject();
// For each map section, "id" is the only required field. This is the field we use to display the location names in the map list, and in various drop-downs.
QString idField = "id";
if (!mapSectionObj.contains(idField)) {
const QString oldIdField = "map_section";
if (mapSectionObj.contains(oldIdField)) {
// User has the old name for this field. Parse using this name, then save with the new name.
// This will presumably stop the user's project from compiling, but that's preferable to
// ignoring everything here and then wiping the file's data when we save later.
idField = oldIdField;
} else {
logWarn(QString("Ignoring data for map section %1 in '%2'. Missing required field \"%3\"").arg(i).arg(filepath).arg(idField));
continue;
}
}
const QString idName = ParseUtil::jsonToQString(mapSectionObj.take(idField));
if (!idName.startsWith(requiredPrefix)) {
logWarn(QString("Ignoring data for map section '%1' in '%2'. IDs must start with the prefix '%3'").arg(idName).arg(filepath).arg(requiredPrefix));
continue;
}
this->mapSectionIdNames.append(idName);
this->mapSectionIdNamesSaveOrder.append(idName);
LocationData location;
if (mapSectionObj.contains("name")) {
location.displayName = ParseUtil::jsonToQString(mapSectionObj.take("name"));
}
// Map sections may have additional data indicating their position on the region map.
// If they have this data, we can add them to the region map entry list.
bool hasRegionMapData = true;
static const QSet<QString> regionMapFieldNames = { "x", "y", "width", "height" };
for (auto fieldName : regionMapFieldNames) {
if (!mapSectionObj.contains(fieldName)) {
hasRegionMapData = false;
break;
}
}
if (hasRegionMapData) {
location.map.x = ParseUtil::jsonToInt(mapSectionObj.take("x"));
location.map.y = ParseUtil::jsonToInt(mapSectionObj.take("y"));
location.map.width = ParseUtil::jsonToInt(mapSectionObj.take("width"));
location.map.height = ParseUtil::jsonToInt(mapSectionObj.take("height"));
location.map.valid = true;
}
// Chuck the "name_clone" field, this is only for matching.
if (!projectConfig.preserveMatchingOnlyData) {
mapSectionObj.remove("name_clone");
}
// Preserve any remaining fields for when we save.
location.custom = mapSectionObj;
this->locationData.insert(idName, location);
}
this->customMapSectionsData = mapSectionsGlobalObj;
// Make sure the default name is present in the list.
if (!this->mapSectionIdNames.contains(defaultName)) {
this->mapSectionIdNames.append(defaultName);
}
Util::numericalModeSort(this->mapSectionIdNames);
return true;
}
void Project::setRegionMapEntries(const QHash<QString, MapSectionEntry> &entries) {
for (auto it = entries.constBegin(); it != entries.constEnd(); it++) {
this->locationData[it.key()].map = it.value();
}
}
QHash<QString, MapSectionEntry> Project::getRegionMapEntries() const {
QHash<QString, MapSectionEntry> entries;
for (auto it = this->locationData.constBegin(); it != this->locationData.constEnd(); it++) {
const MapSectionEntry regionMapData = it.value().map;
if (regionMapData.valid) {
entries[it.key()] = regionMapData;
}
}
return entries;
}
QString Project::getEmptyMapsecName() {
return projectConfig.getIdentifier(ProjectIdentifier::define_map_section_prefix) + projectConfig.getIdentifier(ProjectIdentifier::define_map_section_empty);
}
QString Project::getMapGroupPrefix() {
// We could expose this to users, but it's never enforced so it probably won't affect anyone.
return QStringLiteral("gMapGroup_");
}
bool Project::addNewMapsec(const QString &idName, const QString &displayName) {
if (this->mapSectionIdNames.contains(idName)) {
// Already added
return false;
}
IdentifierValidator validator(projectConfig.getIdentifier(ProjectIdentifier::define_map_section_prefix));
if (!validator.isValid(idName)) {
logWarn(QString("Cannot add new MAPSEC with invalid name '%1'").arg(idName));
return false;
}
if (!this->mapSectionIdNamesSaveOrder.isEmpty() && this->mapSectionIdNamesSaveOrder.last() == getEmptyMapsecName()) {
// If the default map section name (MAPSEC_NONE) is last in the list we'll keep it last in the list.
this->mapSectionIdNamesSaveOrder.insert(this->mapSectionIdNames.length() - 1, idName);
} else {
this->mapSectionIdNamesSaveOrder.append(idName);
}
this->mapSectionIdNames.append(idName);
Util::numericalModeSort(this->mapSectionIdNames);
this->hasUnsavedDataChanges = true;
emit mapSectionAdded(idName);
emit mapSectionIdNamesChanged(this->mapSectionIdNames);
if (!displayName.isEmpty()) setMapsecDisplayName(idName, displayName);
return true;
}
void Project::removeMapsec(const QString &idName) {
if (!this->mapSectionIdNames.contains(idName) || idName == getEmptyMapsecName())
return;
this->mapSectionIdNames.removeOne(idName);
this->mapSectionIdNamesSaveOrder.removeOne(idName);
this->hasUnsavedDataChanges = true;
emit mapSectionIdNamesChanged(this->mapSectionIdNames);
}
void Project::setMapsecDisplayName(const QString &idName, const QString &displayName) {
if (getMapsecDisplayName(idName) == displayName)
return;
this->locationData[idName].displayName = displayName;
this->hasUnsavedDataChanges = true;
emit mapSectionDisplayNameChanged(idName, displayName);
}
void Project::clearHealLocations() {
for (auto &events : this->healLocations) {
qDeleteAll(events);
}
this->healLocations.clear();
this->healLocationSaveOrder.clear();
this->customHealLocationsData = QJsonObject();
}
bool Project::readHealLocations() {
clearHealLocations();
QJsonDocument doc;
const QString filepath = projectConfig.getFilePath(ProjectFilePath::json_heal_locations);
QString error;
if (!parser.tryParseJsonFile(&doc, filepath, &error)) {
logError(QString("Failed to read heal locations from '%1': %2").arg(filepath).arg(error));
return false;
}
watchFile(filepath);
QJsonObject healLocationsObj = doc.object();
QJsonArray healLocations = healLocationsObj.take("heal_locations").toArray();
for (int i = 0; i < healLocations.size(); i++) {
QJsonObject healLocationObj = healLocations.at(i).toObject();
static const QString mapField = QStringLiteral("map");
if (!healLocationObj.contains(mapField)) {
logWarn(QString("Ignoring data for heal location %1 in '%2'. Missing required field \"%3\"").arg(i).arg(filepath).arg(mapField));
continue;
}
auto event = new HealLocationEvent();
event->loadFromJson(healLocationObj, this);
this->healLocations[event->getHostMapName()].append(event);
this->healLocationSaveOrder.append(event->getIdName());
}
this->customHealLocationsData = healLocationsObj;
return true;
}
bool Project::readItemNames() {
const QString filename = projectConfig.getFilePath(ProjectFilePath::constants_items);
watchFile(filename);
QString error;
this->itemNames = parser.readCDefineNames(filename, {projectConfig.getIdentifier(ProjectIdentifier::regex_items)}, &error);
if (!error.isEmpty())
logWarn(QString("Failed to read item constants from '%1': %2").arg(filename).arg(error));
return true;
}
bool Project::readFlagNames() {
const QString filename = projectConfig.getFilePath(ProjectFilePath::constants_flags);
watchFile(filename);
QString error;
this->flagNames = parser.readCDefineNames(filename, {projectConfig.getIdentifier(ProjectIdentifier::regex_flags)}, &error);
if (!error.isEmpty())
logWarn(QString("Failed to read flag constants from '%1': %2").arg(filename).arg(error));
return true;
}
bool Project::readVarNames() {
const QString filename = projectConfig.getFilePath(ProjectFilePath::constants_vars);
watchFile(filename);
QString error;
this->varNames = parser.readCDefineNames(filename, {projectConfig.getIdentifier(ProjectIdentifier::regex_vars)}, &error);
if (!error.isEmpty())
logWarn(QString("Failed to read var constants from '%1': %2").arg(filename).arg(error));
return true;
}
bool Project::readMovementTypes() {
const QString filename = projectConfig.getFilePath(ProjectFilePath::constants_obj_event_movement);
watchFile(filename);
QString error;
this->movementTypes = parser.readCDefineNames(filename, {projectConfig.getIdentifier(ProjectIdentifier::regex_movement_types)}, &error);
if (!error.isEmpty())
logWarn(QString("Failed to read movement type constants from '%1': %2").arg(filename).arg(error));
return true;
}
bool Project::readInitialFacingDirections() {
QString filename = projectConfig.getFilePath(ProjectFilePath::initial_facing_table);
watchFile(filename);
QString error;
this->facingDirections = parser.readNamedIndexCArray(filename, projectConfig.getIdentifier(ProjectIdentifier::symbol_facing_directions), &error);
if (!error.isEmpty())
logWarn(QString("Failed to read initial movement type facing directions from '%1': %2").arg(filename).arg(error));
return true;
}
bool Project::readMapTypes() {
const QString filename = projectConfig.getFilePath(ProjectFilePath::constants_map_types);
// File already being watched
QString error;
this->mapTypes = parser.readCDefineNames(filename, {projectConfig.getIdentifier(ProjectIdentifier::regex_map_types)}, &error);
if (!error.isEmpty())
logWarn(QString("Failed to read map type constants from '%1': %2").arg(filename).arg(error));
return true;
}
bool Project::readMapBattleScenes() {
const QString filename = projectConfig.getFilePath(ProjectFilePath::constants_map_types);
// File already being watched
QString error;
this->mapBattleScenes = parser.readCDefineNames(filename, {projectConfig.getIdentifier(ProjectIdentifier::regex_battle_scenes)}, &error);
if (!error.isEmpty())
logWarn(QString("Failed to read map battle scene constants from '%1': %2").arg(filename).arg(error));
return true;
}
bool Project::readWeatherNames() {
const QString filename = projectConfig.getFilePath(ProjectFilePath::constants_weather);
watchFile(filename);
QString error;
this->weatherNames = parser.readCDefineNames(filename, {projectConfig.getIdentifier(ProjectIdentifier::regex_weather)}, &error);
if (!error.isEmpty())
logWarn(QString("Failed to read weather constants from '%1': %2").arg(filename).arg(error));
return true;
}
bool Project::readCoordEventWeatherNames() {
if (!projectConfig.eventWeatherTriggerEnabled)
return true;
const QString filename = projectConfig.getFilePath(ProjectFilePath::constants_weather);
watchFile(filename);
QString error;
this->coordEventWeatherNames = parser.readCDefineNames(filename, {projectConfig.getIdentifier(ProjectIdentifier::regex_coord_event_weather)}, &error);
if (!error.isEmpty())
logWarn(QString("Failed to read coord event weather constants from '%1': %2").arg(filename).arg(error));
return true;
}
bool Project::readSecretBaseIds() {
if (!projectConfig.eventSecretBaseEnabled)
return true;
const QString filename = projectConfig.getFilePath(ProjectFilePath::constants_secret_bases);
watchFile(filename);
QString error;
this->secretBaseIds = parser.readCDefineNames(filename, {projectConfig.getIdentifier(ProjectIdentifier::regex_secret_bases)}, &error);
if (!error.isEmpty())
logWarn(QString("Failed to read secret base id constants from '%1': %2").arg(filename).arg(error));
return true;
}
bool Project::readBgEventFacingDirections() {
const QString filename = projectConfig.getFilePath(ProjectFilePath::constants_event_bg);
watchFile(filename);
QString error;
this->bgEventFacingDirections = parser.readCDefineNames(filename, {projectConfig.getIdentifier(ProjectIdentifier::regex_sign_facing_directions)}, &error);
if (!error.isEmpty())
logWarn(QString("Failed to read bg event facing direction constants from '%1': %2").arg(filename).arg(error));
return true;
}
bool Project::readTrainerTypes() {
const QString filename = projectConfig.getFilePath(ProjectFilePath::constants_trainer_types);
watchFile(filename);
QString error;
this->trainerTypes = parser.readCDefineNames(filename, {projectConfig.getIdentifier(ProjectIdentifier::regex_trainer_types)}, &error);
if (!error.isEmpty())
logWarn(QString("Failed to read trainer type constants from '%1': %2").arg(filename).arg(error));
return true;
}
bool Project::readMetatileBehaviors() {
this->metatileBehaviorMap.clear();
this->metatileBehaviorMapInverse.clear();
QString filename = projectConfig.getFilePath(ProjectFilePath::constants_metatile_behaviors);
watchFile(filename);
QString error;
const auto defines = parser.readCDefinesByRegex(filename, {projectConfig.getIdentifier(ProjectIdentifier::regex_behaviors)}, &error);
if (defines.isEmpty() && projectConfig.metatileBehaviorMask) {
// Not having any metatile behavior names is ok (their values will be displayed instead)
// but if the user's metatiles can have nonzero values then warn them, as they likely want names.
QString warning = QString("Failed to read metatile behaviors from '%1'").arg(filename);
if (!error.isEmpty()) warning += QString(": %1").arg(error);
logWarn(warning);
}
for (auto i = defines.cbegin(), end = defines.cend(); i != end; i++) {
uint32_t value = static_cast<uint32_t>(i.value());
this->metatileBehaviorMap.insert(i.key(), value);
this->metatileBehaviorMapInverse.insert(value, i.key());
}
return true;
}
bool Project::readSongNames() {
const QString filename = projectConfig.getFilePath(ProjectFilePath::constants_songs);
watchFile(filename);
QString error;
this->songNames = parser.readCDefineNames(filename, {projectConfig.getIdentifier(ProjectIdentifier::regex_music)}, &error);
if (!error.isEmpty())
logWarn(QString("Failed to read song names from '%1': %2").arg(filename).arg(error));
// Song names don't have a very useful order (esp. if we include SE_* values), so sort them alphabetically.
// The default song should be the first in the list, not the first alphabetically, so save that before sorting.
this->defaultSong = this->songNames.value(0, "0");
Util::numericalModeSort(this->songNames);
return true;
}
bool Project::readObjEventGfxConstants() {
QString filename = projectConfig.getFilePath(ProjectFilePath::constants_obj_events);
watchFile(filename);
QString error;
const auto defines = parser.readCDefinesByRegex(filename, {projectConfig.getIdentifier(ProjectIdentifier::regex_obj_event_gfx)}, &error);
if (!error.isEmpty())
logWarn(QString("Failed to read object event graphics constants from '%1': %2").arg(filename).arg(error));
this->gfxDefines.clear();
for (auto it = defines.constBegin(); it != defines.constEnd(); it++)
this->gfxDefines.insert(it.key(), it.value());
return true;
}
bool Project::readMiscellaneousConstants() {
const QString filename = projectConfig.getFilePath(ProjectFilePath::constants_global);
const QString maxObjectEventsName = projectConfig.getIdentifier(ProjectIdentifier::define_obj_event_count);
watchFile(filename);
const auto defines = parser.readCDefinesByName(filename, {maxObjectEventsName});
this->maxObjectEvents = 64; // Default value
auto it = defines.find(maxObjectEventsName);
if (it != defines.end()) {
if (it.value() > 0) {
this->maxObjectEvents = it.value();
} else {
logWarn(QString("Value for '%1' is %2, must be greater than 0. Using default (%3) instead.")
.arg(maxObjectEventsName)
.arg(it.value())
.arg(this->maxObjectEvents));
}
}
else {
logWarn(QString("Value for '%1' not found. Using default (%2) instead.")
.arg(maxObjectEventsName)
.arg(this->maxObjectEvents));
}
return true;
}
bool Project::readGlobalConstants() {
this->parser.resetCDefines();
for (const auto &path : projectConfig.globalConstantsFilepaths) {
QString error;
this->parser.loadGlobalCDefinesFromFile(path, &error);
if (!error.isEmpty()) {
logWarn(QString("Failed to read global constants file '%1': %2").arg(path).arg(error));
}
}
this->parser.loadGlobalCDefines(projectConfig.globalConstants);
return true;
}
bool Project::readEventScriptLabels() {
this->globalScriptLabels.clear();
if (porymapConfig.loadAllEventScripts) {
for (const auto &filePath : getEventScriptsFilepaths())
this->globalScriptLabels << ParseUtil::getGlobalScriptLabels(filePath);
this->globalScriptLabels.sort(Qt::CaseInsensitive);
this->globalScriptLabels.removeDuplicates();
}
emit eventScriptLabelsRead();
return true;
}
void Project::insertGlobalScriptLabels(QStringList &scriptLabels) const {
if (this->globalScriptLabels.isEmpty())
return;
scriptLabels.append(this->globalScriptLabels);
scriptLabels.sort();
scriptLabels.removeDuplicates();
}
QString Project::fixPalettePath(const QString &path) const {
return Util::replaceExtension(path, QStringLiteral("pal"));
}
QString Project::fixGraphicPath(const QString &path) const {
return Util::replaceExtension(path, QStringLiteral("png"));
}
QString Project::getScriptFileExtension(bool usePoryScript) {
if(usePoryScript) {
return ".pory";
} else {
return ".inc";
}
}
QString Project::getScriptDefaultString(bool usePoryScript, QString mapName) const {
if(usePoryScript)
return QString("mapscripts %1_MapScripts {}\n").arg(mapName);
else
return QString("%1_MapScripts::\n\t.byte 0\n").arg(mapName);
}
QStringList Project::getEventScriptsFilepaths() const {
QStringList filePaths(QDir::cleanPath(root + "/" + projectConfig.getFilePath(ProjectFilePath::data_event_scripts)));
const QString scriptsDir = QDir::cleanPath(root + "/" + projectConfig.getFilePath(ProjectFilePath::data_scripts_folders));
const QString mapsDir = QDir::cleanPath(root + "/" + projectConfig.getFilePath(ProjectFilePath::data_map_folders));
if (projectConfig.usePoryScript) {
QDirIterator it_pory_shared(scriptsDir, {"*.pory"}, QDir::Files);
while (it_pory_shared.hasNext())
filePaths << it_pory_shared.next();
QDirIterator it_pory_maps(mapsDir, {"scripts.pory"}, QDir::Files, QDirIterator::Subdirectories);
while (it_pory_maps.hasNext())
filePaths << it_pory_maps.next();
}
QDirIterator it_inc_shared(scriptsDir, {"*.inc"}, QDir::Files);
while (it_inc_shared.hasNext())
filePaths << it_inc_shared.next();
QDirIterator it_inc_maps(mapsDir, {"scripts.inc"}, QDir::Files, QDirIterator::Subdirectories);
while (it_inc_maps.hasNext())
filePaths << it_inc_maps.next();
return filePaths;
}
void Project::loadEventPixmap(Event *event, bool forceLoad) {
if (event && (event->getPixmap().isNull() || forceLoad))
event->loadPixmap(this);
}
void Project::clearEventGraphics() {
qDeleteAll(this->eventGraphicsMap);
this->eventGraphicsMap.clear();
}
bool Project::readEventGraphics() {
clearEventGraphics();
const QString pointersFilepath = projectConfig.getFilePath(ProjectFilePath::data_obj_event_gfx_pointers);
const QString gfxInfoFilepath = projectConfig.getFilePath(ProjectFilePath::data_obj_event_gfx_info);
const QString picTablesFilepath = projectConfig.getFilePath(ProjectFilePath::data_obj_event_pic_tables);
const QString gfxFilepath = projectConfig.getFilePath(ProjectFilePath::data_obj_event_gfx);
watchFiles({pointersFilepath, gfxInfoFilepath, picTablesFilepath, gfxFilepath});
// Read the table mapping OBJ_EVENT_GFX constants to the names of pointers to data about their graphics.
const QString pointersName = projectConfig.getIdentifier(ProjectIdentifier::symbol_obj_event_gfx_pointers);
const QMap<QString, QString> pointerMap = parser.readNamedIndexCArray(pointersFilepath, pointersName);
// The positions of each of the required members for the gfx info struct.
// For backwards compatibility if the struct doesn't use initializers.
static const QHash<int, QString> gfxInfoMemberMap = {
{4, "width"},
{5, "height"},
{8, "inanimate"},
{12, "subspriteTables"},
{14, "images"},
};
// Read the structs containing data about each of the event sprites.
auto gfxInfos = parser.readCStructs(gfxInfoFilepath, "", gfxInfoMemberMap);
// We need data in both of these files to translate data from the structs above into the path for a .png file.
const QMap<QString, QStringList> picTables = parser.readCArrayMulti(picTablesFilepath);
const QMap<QString, QString> graphicIncbins = parser.readCIncbinMulti(gfxFilepath);
for (auto i = this->gfxDefines.constBegin(); i != this->gfxDefines.constEnd(); i++) {
const QString gfxName = i.key();
// Strip the address-of operator to get the pointer's name. We'll use this name to get data about the event's sprite.
// If we don't recognize the name, ignore it. The event will use a default sprite.
QString info_label = pointerMap.value(gfxName);
info_label.replace("&", "");
if (!gfxInfos.contains(info_label))
continue;
const QHash<QString, QString> gfxInfoAttributes = gfxInfos[info_label];
auto gfx = new EventGraphics;
// We need the .png filepath for the event's sprite. This is buried behind a few levels of indirection.
// The 'images' field gives us the name of the table containing the sprite's image data.
// The entries in this table are expected to be in the format (PngSymbolName, ...).
// We extract the symbol name of the .png's INCBIN'd data by looking at the first entry in this table.
// Once we have the .png's symbol name we can get the actual filepath from its INCBIN.
QString gfx_label = picTables[gfxInfoAttributes.value("images")].value(0);
static const QRegularExpression re_parens("[\\(\\)]");
gfx_label = gfx_label.section(re_parens, 1, 1);
gfx->filepath = fixGraphicPath(graphicIncbins[gfx_label]);
// Note: gfx has a 'spritesheet' field that will contain a QImage for the event's sprite.
// We don't create this QImage yet. Reading the image now is unnecessary overhead for startup.
// We'll read the image file when the event's sprite is first requested to be drawn.
// The .png file is expected to be a spritesheet that can have multiple frames.
// We only want to show one frame at a time, so we need to know the dimensions of each frame.
// The true dimensions are buried in the subsprite data, so we try to infer the dimensions from the name of the 'subspriteTables' symbol.
// If we are unable to do this, we can read the dimensions from the width and height fields.
// This is much more straightforward, but the numbers are not necessarily accurate (one vanilla event sprite,
// the Town Map in FRLG, has width/height values that differ from its true dimensions).
static const QRegularExpression re_dimensions("\\S+_(\\d+)x(\\d+)");
const QRegularExpressionMatch dimensionsMatch = re_dimensions.match(gfxInfoAttributes.value("subspriteTables"));
if (dimensionsMatch.hasMatch()) {
gfx->spriteWidth = dimensionsMatch.captured(1).toInt(nullptr, 0);
gfx->spriteHeight = dimensionsMatch.captured(2).toInt(nullptr, 0);
} else if (gfxInfoAttributes.contains("width") && gfxInfoAttributes.contains("height")) {
gfx->spriteWidth = gfxInfoAttributes.value("width").toInt(nullptr, 0);
gfx->spriteHeight = gfxInfoAttributes.value("height").toInt(nullptr, 0);
}
// If we fail to get sprite dimensions then they should remain -1, and the sprite will use the full spritesheet as its image.
if (gfx->spriteWidth <= 0 || gfx->spriteHeight <= 0) {
gfx->spriteWidth = -1;
gfx->spriteHeight = -1;
}
// Inanimate events will only ever use the first frame of their spritesheet.
gfx->inanimate = ParseUtil::gameStringToBool(gfxInfoAttributes.value("inanimate"));
this->eventGraphicsMap.insert(gfxName, gfx);
}
return true;
}
QPixmap Project::getEventPixmap(const QString &gfxName, const QString &movementName) {
struct FrameData {
int index = 0;
bool hFlip = false;
};
// TODO: Expose as a setting to users
static const QMap<QString, FrameData> directionToFrameData = {
{"DIR_SOUTH", { .index = 0, .hFlip = false }},
{"DIR_NORTH", { .index = 1, .hFlip = false }},
{"DIR_WEST", { .index = 2, .hFlip = false }},
{"DIR_EAST", { .index = 2, .hFlip = true }}, // East-facing sprite is just the West-facing sprite mirrored
};
const QString direction = this->facingDirections.value(movementName, "DIR_SOUTH");
auto frameData = directionToFrameData.value(direction);
return getEventPixmap(gfxName, frameData.index, frameData.hFlip);
}
QPixmap Project::getEventPixmap(const QString &gfxName, int frame, bool hFlip) {
QPixmap pixmap;
const QString cacheKey = QString("EVENT#%1#%2#%3").arg(gfxName).arg(frame).arg(hFlip ? "1" : "0");
if (QPixmapCache::find(cacheKey, &pixmap)) {
return pixmap;
}
EventGraphics* gfx = this->eventGraphicsMap.value(gfxName, nullptr);
if (!gfx) {
// Invalid gfx constant. If this is a number, try to use that instead.
bool ok;
int gfxNum = ParseUtil::gameStringToInt(gfxName, &ok);
if (ok) gfx = this->eventGraphicsMap.value(this->gfxDefines.key(gfxNum, "NULL"), nullptr);
}
if (gfx && !gfx->loaded) {
// This is the first request for this event's sprite. We'll attempt to load it now.
if (!gfx->filepath.isEmpty()) {
gfx->spritesheet = QImage(QString("%1/%2").arg(this->root).arg(gfx->filepath));
if (gfx->spritesheet.isNull()) {
logWarn(QString("Failed to open '%1' for event's sprite. Event will use a default sprite instead.").arg(gfx->filepath));
} else {
// If we were unable to find the dimensions of a frame within the spritesheet we'll use the full image dimensions.
if (gfx->spriteWidth <= 0) {
gfx->spriteWidth = gfx->spritesheet.width();
}
if (gfx->spriteHeight <= 0) {
gfx->spriteHeight = gfx->spritesheet.height();
}
}
}
// Set this whether we were successful or not, we only need to try to load it once.
gfx->loaded = true;
}
if (!gfx || gfx->spritesheet.width() == 0 || gfx->spritesheet.height() == 0) {
// Either we didn't recognize the gfxName, or we were unable to load the sprite's image.
return QPixmap();
}
QImage img;
if (gfx->inanimate) {
img = gfx->spritesheet.copy(0, 0, gfx->spriteWidth, gfx->spriteHeight);
} else {
int x = frame * gfx->spriteWidth;
int y = ((frame * gfx->spriteWidth) / gfx->spritesheet.width()) * gfx->spriteHeight;
img = gfx->spritesheet.copy(x % gfx->spritesheet.width(),
y % gfx->spritesheet.height(),
gfx->spriteWidth,
gfx->spriteHeight);
if (hFlip) {
img = img.transformed(QTransform().scale(-1, 1));
}
}
// Set first palette color fully transparent.
img.setColor(0, qRgba(0, 0, 0, 0));
pixmap = QPixmap::fromImage(img);
QPixmapCache::insert(cacheKey, pixmap);
return pixmap;
}
QPixmap Project::getEventPixmap(Event::Group group) {
if (group == Event::Group::None)
return QPixmap();
QPixmap pixmap;
const QString cacheKey = QString("EVENT#%1").arg(Event::groupToString(group));
if (QPixmapCache::find(cacheKey, &pixmap)) {
return pixmap;
}
const int defaultWidth = 16;
const int defaultHeight = 16;
static const QPixmap defaultIcons = QPixmap(":/images/Entities_16x16.png");
QPixmap defaultIcon = QPixmap(defaultIcons.copy(static_cast<int>(group) * defaultWidth, 0, defaultWidth, defaultHeight));
// Custom event icons may be provided by the user.
QString customIconPath = projectConfig.getEventIconPath(group);
if (customIconPath.isEmpty()) {
// No custom icon specified, use the default icon.
pixmap = defaultIcon;
} else {
// Try to load custom icon
QString validPath = Project::getExistingFilepath(customIconPath);
if (!validPath.isEmpty()) customIconPath = validPath; // Otherwise allow it to fail with the original path
pixmap = QPixmap(customIconPath);
if (pixmap.isNull()) {
pixmap = defaultIcon;
logWarn(QString("Failed to load custom event icon '%1', using default icon.").arg(customIconPath));
}
}
QPixmapCache::insert(cacheKey, pixmap);
return pixmap;
}
bool Project::readSpeciesIconPaths() {
this->speciesToIconPath.clear();
this->speciesNames.clear();
// Read map of species constants to icon names
const QString srcfilename = projectConfig.getFilePath(ProjectFilePath::pokemon_icon_table);
watchFile(srcfilename);
const QString tableName = projectConfig.getIdentifier(ProjectIdentifier::symbol_pokemon_icon_table);
const QMap<QString, QString> monIconNames = parser.readNamedIndexCArray(srcfilename, tableName);
// Read species constants. If this fails we can get them from the icon table (but we shouldn't rely on it).
const QString speciesPrefix = projectConfig.getIdentifier(ProjectIdentifier::define_species_prefix);
const QString constantsFilename = projectConfig.getFilePath(ProjectFilePath::constants_species);
watchFile(constantsFilename);
this->speciesNames = parser.readCDefineNames(constantsFilename, {QString("\\b%1").arg(speciesPrefix)});
if (this->speciesNames.isEmpty()) {
this->speciesNames = monIconNames.keys();
}
this->speciesNames.sort();
// If we successfully found the species icon table we can use this data to get the filepath for each species icon.
// For any species not in the table, or if we failed to find the table at all, we will have to predict where the icon file is.
// That can require checking a lot of files (especially for projects with many species), so to save time on startup we only
// do this on request in Project::getDefaultSpeciesIconPath.
if (!monIconNames.isEmpty()) {
const QString iconGraphicsFile = projectConfig.getFilePath(ProjectFilePath::data_pokemon_gfx);
watchFile(iconGraphicsFile);
QMap<QString, QString> iconNameToFilepath = parser.readCIncbinMulti(iconGraphicsFile);
for (auto i = monIconNames.constBegin(); i != monIconNames.constEnd(); i++) {
QString path;
QString species = i.key();
QString iconName = i.value();
if (iconNameToFilepath.contains(iconName)) {
path = fixGraphicPath(iconNameToFilepath.value(iconName));
} else {
// We have an icon name for this species, but we haven't found its filepath.
// Try to find the icon file using the full icon name, and the icon name if we assume it has a prefix.
// Ex: For 'gMonIcon_QuestionMark' search for files by permuting through directories using 'question_mark' and 'g_mon_icon_question_mark.
static const QRegularExpression re_caseChange("([a-z])([A-Z0-9])");
QStringList dirNames;
if (iconName.contains("_")) {
QString iconNameNoPrefix = iconName.mid(iconName.indexOf("_") + 1);
dirNames.append(iconNameNoPrefix.replace(re_caseChange, "\\1_\\2").toLower());
}
QString iconNameWithPrefix = iconName; // Leave iconName unchanged by .replace
dirNames.append(iconNameWithPrefix.replace(re_caseChange, "\\1_\\2").toLower());
path = iconNameToFilepath[iconName] = findSpeciesIconPath(dirNames);
}
if (!path.isEmpty()) {
this->speciesToIconPath.insert(species, QString("%1/%2").arg(this->root).arg(path));
}
}
}
return true;
}
QString Project::getDefaultSpeciesIconPath(const QString &species) {
if (this->speciesToIconPath.contains(species)) {
// We already know the icon path for this species (either because we read it from the project, or we found it already).
return this->speciesToIconPath.value(species);
}
if (!this->speciesNames.contains(species)) {
// Don't bother searching for a path if we don't recognize the species name.
return QString();
}
// Ex: For 'SPECIES_FOO_BAR_BAZ' search for files by permuting through directories using 'foo_bar_baz'.
const QString speciesPrefix = projectConfig.getIdentifier(ProjectIdentifier::define_species_prefix);
const QString path = findSpeciesIconPath({species.mid(speciesPrefix.length()).toLower()});
this->speciesToIconPath.insert(species, path);
// We failed to find a default icon path, this species will use a placeholder icon.
// If the user has no custom icon path for this species, tell them they can provide one.
if (path.isEmpty() && projectConfig.getPokemonIconPath(species).isEmpty()) {
logWarn(QString("Failed to find Pokémon icon for '%1'. The filepath can be specified under 'Options->Project Settings'").arg(species));
}
return path;
}
// The name permuting in here is overkill, but it's making up for some of the fragility in the way we find pokémon icon paths.
// For pokeemerald-expansion in particular this function is solely responsible for finding pokémon icons, because they have no icon table.
QString Project::findSpeciesIconPath(const QStringList &names) const {
QStringList possibleDirNames = names;
// Permute paths with underscores.
// Ex: For a base name of 'foo_bar_baz', try 'foo_bar/baz', 'foo/bar_baz', 'foobarbaz', 'foo_bar', and 'foo'.
QStringList permutedNames;
for (auto dir : possibleDirNames) {
if (!dir.contains("_")) continue;
for (int i = dir.indexOf("_"); i > -1; i = dir.indexOf("_", i + 1)) {
QString temp = dir;
permutedNames.prepend(temp.replace(i, 1, "/"));
permutedNames.append(dir.left(i)); // Prepend the others so the most generic name ('foo') ends up last
}
permutedNames.prepend(dir.remove("_"));
}
possibleDirNames.append(permutedNames);
possibleDirNames.removeDuplicates();
const QString basePath = QString("%1/%2").arg(this->root).arg(projectConfig.getFilePath(ProjectFilePath::pokemon_gfx));
for (const auto &dir : possibleDirNames) {
if (dir.isEmpty()) continue;
const QString path = QString("%1%2/icon.png").arg(basePath).arg(dir);
if (QFile::exists(path))
return path;
}
return QString();
}
QPixmap Project::getSpeciesIcon(const QString &species) {
QPixmap pixmap;
if (!QPixmapCache::find(species, &pixmap)) {
// Prefer path from config. If not present, use the path parsed from project files
QString path = Project::getExistingFilepath(projectConfig.getPokemonIconPath(species));
if (path.isEmpty()) {
path = getDefaultSpeciesIconPath(species);
}
QImage img(path);
if (img.isNull()) {
// No icon for this species, use placeholder
static const QPixmap placeholder = QPixmap(QStringLiteral(":images/pokemon_icon_placeholder.png"));
pixmap = placeholder;
} else {
img.setColor(0, qRgba(0, 0, 0, 0));
pixmap = QPixmap::fromImage(img).copy(0, 0, 32, 32);
QPixmapCache::insert(species, pixmap);
}
}
return pixmap;
}
int Project::getMapDataSize(int width, int height) const {
return (width + this->mapSizeAddition.width())
* (height + this->mapSizeAddition.height());
}
int Project::getMaxMapWidth() const {
return (getMaxMapDataSize() / (1 + this->mapSizeAddition.height())) - this->mapSizeAddition.width();
}
int Project::getMaxMapHeight() const {
return (getMaxMapDataSize() / (1 + this->mapSizeAddition.width())) - this->mapSizeAddition.height();
}
bool Project::mapDimensionsValid(int width, int height) const {
return getMapDataSize(width, height) <= getMaxMapDataSize();
}
// Object events have their own limit specified by ProjectIdentifier::define_obj_event_count.
// The default value for this is 64. All events (object events included) are also limited by
// the data types of the event counters in the project. This would normally be u8, so the limit is 255.
// We let the users tell us this limit in case they change these data types.
int Project::getMaxEvents(Event::Group group) const {
if (group == Event::Group::Object)
return qMin(this->maxObjectEvents, projectConfig.maxEventsPerGroup);
return projectConfig.maxEventsPerGroup;
}
QString Project::getEmptyMapDefineName() {
return projectConfig.getIdentifier(ProjectIdentifier::define_map_empty);
}
QString Project::getDynamicMapDefineName() {
return projectConfig.getIdentifier(ProjectIdentifier::define_map_dynamic);
}
QString Project::getDynamicMapName() {
return projectConfig.getIdentifier(ProjectIdentifier::symbol_dynamic_map_name);
}
QString Project::getEmptySpeciesName() {
return projectConfig.getIdentifier(ProjectIdentifier::define_species_prefix) + projectConfig.getIdentifier(ProjectIdentifier::define_species_empty);
}
// Get the distance in pixels that the player is able to see in each direction in-game,
// rounded up to a multiple of a metatile's pixel size.
QMargins Project::getPixelViewDistance() {
QMargins viewDistance = projectConfig.playerViewDistance;
viewDistance.setTop(Util::roundUpToMultiple(viewDistance.top(), Metatile::pixelHeight()));
viewDistance.setBottom(Util::roundUpToMultiple(viewDistance.bottom(), Metatile::pixelHeight()));
viewDistance.setLeft(Util::roundUpToMultiple(viewDistance.left(), Metatile::pixelWidth()));
viewDistance.setRight(Util::roundUpToMultiple(viewDistance.right(), Metatile::pixelWidth()));
return viewDistance;
}
// Get the distance in metatiles that the player is able to see in each direction in-game.
// For the default view distance (i.e. assuming the player is centered in a 240x160 pixel GBA screen) this is 7x5 metatiles.
QMargins Project::getMetatileViewDistance() {
QMargins viewDistance = getPixelViewDistance();
viewDistance.setTop(viewDistance.top() / Metatile::pixelHeight());
viewDistance.setBottom(viewDistance.bottom() / Metatile::pixelHeight());
viewDistance.setLeft(viewDistance.left() / Metatile::pixelWidth());
viewDistance.setRight(viewDistance.right() / Metatile::pixelWidth());
return viewDistance;
}
// If the provided filepath is an absolute path to an existing file, return filepath.
// If not, and the provided filepath is a relative path from the project dir to an existing file, return the relative path.
// Otherwise return empty string.
QString Project::getExistingFilepath(QString filepath) {
if (filepath.isEmpty() || QFile::exists(filepath))
return filepath;
filepath = QDir::cleanPath(projectConfig.projectDir() + QDir::separator() + filepath);
if (QFile::exists(filepath))
return filepath;
return QString();
}
// The values of some config fields can limit the values of other config fields
// (for example, metatile attributes size limits the metatile attribute masks).
// Others depend on information in the project (for example the default metatile ID
// can be limited by fieldmap defines)
// Once we've read data from the project files we can adjust these accordingly.
void Project::applyParsedLimits() {
uint32_t maxMask = Metatile::getMaxAttributesMask();
projectConfig.metatileBehaviorMask &= maxMask;
projectConfig.metatileTerrainTypeMask &= maxMask;
projectConfig.metatileEncounterTypeMask &= maxMask;
projectConfig.metatileLayerTypeMask &= maxMask;
Metatile::setLayout(this);
Project::num_metatiles_primary = qBound(1, Project::num_metatiles_primary, Block::getMaxMetatileId() + 1);
projectConfig.defaultMetatileId = qMin(projectConfig.defaultMetatileId, Block::getMaxMetatileId());
projectConfig.defaultElevation = qMin(projectConfig.defaultElevation, Block::getMaxElevation());
projectConfig.defaultCollision = qMin(projectConfig.defaultCollision, Block::getMaxCollision());
projectConfig.collisionSheetSize.setHeight(qBound(1, projectConfig.collisionSheetSize.height(), Block::getMaxElevation() + 1));
projectConfig.collisionSheetSize.setWidth(qBound(1, projectConfig.collisionSheetSize.width(), Block::getMaxCollision() + 1));
}
bool Project::hasUnsavedChanges() {
if (this->hasUnsavedDataChanges)
return true;
// Check layouts for unsaved changes
for (const auto &layout : this->mapLayouts) {
if (layout->hasUnsavedChanges())
return true;
}
// Check maps for unsaved changes
for (const auto &map : this->maps) {
if (map->hasUnsavedChanges())
return true;
}
return false;
}
Reference in New Issue View Git Blame Copy Permalink