atiran/porymap
4
Fork 0
Code Issues Pull requests Projects Releases 1 Packages Wiki Activity Actions

Merge branch 'master' into pokefirered

Browse source
This commit is contained in:
GriffinR 2020-04-19 09:48:21 -04:00 committed by GitHub
commit 8c428c578b
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
15 changed files with 3540 additions and 84 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

1
.gitignore vendored
View file

@ -3,6 +3,7 @@ porymap.pro.user
*.autosave
*.stash
*.o
*.DS_Store
porymap.app*
porymap
porymap.cfg

21
include/core/event.h
View file

@ -4,7 +4,10 @@
#include <QString>
#include <QPixmap>
#include <QMap>
#include <QJsonObject>
#include "orderedjson.h"
using OrderedJson = poryjson::Json;
class EventType
{
@ -67,19 +70,19 @@ public:
static Event* createNewHiddenItemEvent(Project*);
static Event* createNewSecretBaseEvent(Project*);
QJsonObject buildObjectEventJSON();
QJsonObject buildWarpEventJSON(QMap<QString, QString>*);
QJsonObject buildTriggerEventJSON();
QJsonObject buildWeatherTriggerEventJSON();
QJsonObject buildSignEventJSON();
QJsonObject buildHiddenItemEventJSON();
QJsonObject buildSecretBaseEventJSON();
OrderedJson::object buildObjectEventJSON();
OrderedJson::object buildWarpEventJSON(QMap<QString, QString>*);
OrderedJson::object buildTriggerEventJSON();
OrderedJson::object buildWeatherTriggerEventJSON();
OrderedJson::object buildSignEventJSON();
OrderedJson::object buildHiddenItemEventJSON();
OrderedJson::object buildSecretBaseEventJSON();
void setPixmapFromSpritesheet(QImage, int, int, int, bool);
int getPixelX();
int getPixelY();
QMap<QString, bool> getExpectedFields();
void readCustomValues(QJsonObject values);
void addCustomValuesTo(QJsonObject *obj);
void addCustomValuesTo(OrderedJson::object *obj);
void setFrameFromMovement(QString);
QMap<QString, QString> values;

1
include/core/tileset.h
View file

@ -35,6 +35,7 @@ public:
static Metatile* getMetatile(int, Tileset*, Tileset*);
static QList<QList<QRgb>> getBlockPalettes(Tileset*, Tileset*);
static QList<QRgb> getPalette(int, Tileset*, Tileset*);
static bool metatileIsValid(uint16_t metatileId, Tileset *, Tileset *);
bool appendToHeaders(QString headerFile, QString friendlyName);
bool appendToGraphics(QString graphicsFile, QString friendlyName, bool primary);

241
include/lib/orderedjson.h Normal file
View file

@ -0,0 +1,241 @@
/* poryjson
*
* poryjson is a modified version of json11, which adds support to preserve the key order
* when dumping json objects, and support to Qt classes
*
* json11 is a tiny JSON library for C++11, providing JSON parsing and serialization.
*
* The core object provided by the library is json11::Json. A Json object represents any JSON
* value: null, bool, number (int or double), string (std::string), array (std::vector), or
* object (std::map).
*
* Json objects act like values: they can be assigned, copied, moved, compared for equality or
* order, etc. There are also helper methods Json::dump, to serialize a Json to a string, and
* Json::parse (static) to parse a std::string as a Json object.
*
* Internally, the various types of Json object are represented by the JsonValue class
* hierarchy.
*
* A note on numbers - JSON specifies the syntax of number formatting but not its semantics,
* so some JSON implementations distinguish between integers and floating-point numbers, while
* some don't. In json11, we choose the latter. Because some JSON implementations (namely
* Javascript itself) treat all numbers as the same type, distinguishing the two leads
* to JSON that will be *silently* changed by a round-trip through those implementations.
* Dangerous! To avoid that risk, json11 stores all numbers as double internally, but also
* provides integer helpers.
*
* Fortunately, double-precision IEEE754 ('double') can precisely store any integer in the
* range +/-2^53, which includes every 'int' on most systems. (Timestamps often use int64
* or long long to avoid the Y2038K problem; a double storing microseconds since some epoch
* will be exact for +/- 275 years.)
*/
/* Copyright (c) 2013 Dropbox, Inc.
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
#pragma once
#include <QString>
#include <QVector>
#include <QPair>
#include <QFile>
#include <QTextStream>
#include <memory>
#include <initializer_list>
#include "orderedmap.h"
#ifdef _MSC_VER
#if _MSC_VER <= 1800 // VS 2013
#ifndef noexcept
#define noexcept throw()
#endif
#ifndef snprintf
#define snprintf _snprintf_s
#endif
#endif
#endif
namespace poryjson {
enum JsonParse {
STANDARD, COMMENTS
};
class JsonValue;
class Json final {
public:
// Types
enum Type {
NUL, NUMBER, BOOL, STRING, ARRAY, OBJECT
};
// Array and object typedefs
typedef QVector<Json> array;
typedef tsl::ordered_map<QString, Json> object;
// Constructors for the various types of JSON value.
Json() noexcept; // NUL
Json(std::nullptr_t) noexcept; // NUL
Json(double value); // NUMBER
Json(int value); // NUMBER
Json(bool value); // BOOL
Json(const QString &value); // STRING
Json(QString &&value); // STRING
Json(const char * value); // STRING
Json(const array &values); // ARRAY
Json(array &&values); // ARRAY
Json(const object &values); // OBJECT
Json(object &&values); // OBJECT
// Implicit constructor: anything with a to_json() function.
template <class T, class = decltype(&T::to_json)>
Json(const T & t) : Json(t.to_json()) {}
// Implicit constructor: map-like objects (std::map, std::unordered_map, etc)
template <class M, typename std::enable_if<
std::is_constructible<QString, decltype(std::declval<M>().begin()->first)>::value
&& std::is_constructible<Json, decltype(std::declval<M>().begin()->second)>::value,
int>::type = 0>
Json(const M & m) : Json(object(m.begin(), m.end())) {}
// Implicit constructor: vector-like objects (std::list, std::vector, std::set, etc)
template <class V, typename std::enable_if<
std::is_constructible<Json, decltype(*std::declval<V>().begin())>::value,
int>::type = 0>
Json(const V & v) : Json(array(v.begin(), v.end())) {}
// This prevents Json(some_pointer) from accidentally producing a bool. Use
// Json(bool(some_pointer)) if that behavior is desired.
Json(void *) = delete;
// Accessors
Type type() const;
bool is_null() const { return type() == NUL; }
bool is_number() const { return type() == NUMBER; }
bool is_bool() const { return type() == BOOL; }
bool is_string() const { return type() == STRING; }
bool is_array() const { return type() == ARRAY; }
bool is_object() const { return type() == OBJECT; }
// Return the enclosed value if this is a number, 0 otherwise. Note that poryjson does not
// distinguish between integer and non-integer numbers - number_value() and int_value()
// can both be applied to a NUMBER-typed object.
double number_value() const;
int int_value() const;
// Return the enclosed value if this is a boolean, false otherwise.
bool bool_value() const;
// Return the enclosed string if this is a string, "" otherwise.
const QString &string_value() const;
// Return the enclosed std::vector if this is an array, or an empty vector otherwise.
const array &array_items() const;
// Return the enclosed std::map if this is an object, or an empty map otherwise.
const object &object_items() const;
// Return a reference to arr[i] if this is an array, Json() otherwise.
const Json & operator[](int i) const;
// Return a reference to obj[key] if this is an object, Json() otherwise.
const Json & operator[](const QString &key) const;
// Serialize.
void dump(QString &out, int *) const;
QString dump(int *indent = nullptr) const {
QString out;
if (!indent) {
int temp = 0;
indent = &temp;
}
dump(out, indent);
return out;
}
// Parse. If parse fails, return Json() and assign an error message to err.
static Json parse(const QString & in,
QString & err,
JsonParse strategy = JsonParse::STANDARD);
static Json parse(const char * in,
QString & err,
JsonParse strategy = JsonParse::STANDARD) {
if (in) {
return parse(QString(in), err, strategy);
} else {
err = "null input";
return nullptr;
}
}
bool operator== (const Json &rhs) const;
bool operator< (const Json &rhs) const;
bool operator!= (const Json &rhs) const { return !(*this == rhs); }
bool operator<= (const Json &rhs) const { return !(rhs < *this); }
bool operator> (const Json &rhs) const { return (rhs < *this); }
bool operator>= (const Json &rhs) const { return !(*this < rhs); }
private:
std::shared_ptr<JsonValue> m_ptr;
};
class JsonDoc {
public:
JsonDoc(Json *object) {
this->m_obj = object;
this->m_indent = 0;
};
void dump(QFile *file) {
QTextStream fileStream(file);
fileStream << m_obj->dump(&m_indent);
fileStream << "\n"; // pad file with newline
}
private:
Json *m_obj;
int m_indent;
};
// Internal class hierarchy - JsonValue objects are not exposed to users of this API.
class JsonValue {
protected:
friend class Json;
friend class JsonInt;
friend class JsonDouble;
virtual Json::Type type() const = 0;
virtual bool equals(const JsonValue * other) const = 0;
virtual bool less(const JsonValue * other) const = 0;
virtual void dump(QString &out, int *indent) const = 0;
virtual double number_value() const;
virtual int int_value() const;
virtual bool bool_value() const;
virtual const QString &string_value() const;
virtual const Json::array &array_items() const;
virtual const Json &operator[](int i) const;
virtual const Json::object &object_items() const;
virtual const Json &operator[](const QString &key) const;
virtual ~JsonValue() {}
};
} // namespace poryjson

2406
include/lib/orderedmap.h Normal file
View file

File diff suppressed because it is too large Load diff

3
include/project.h
View file

@ -7,6 +7,7 @@
#include "event.h"
#include "wildmoninfo.h"
#include "parseutil.h"
#include "orderedjson.h"
#include <QStringList>
#include <QList>
@ -94,7 +95,7 @@ public:
QMap<QString, QMap<QString, WildPokemonHeader>> wildMonData;
QVector<EncounterField> wildMonFields;
QVector<QString> encounterGroupLabels;
QMap<QString, QJsonObject> extraEncounterGroups;
QVector<poryjson::Json::object> extraEncounterGroups;
bool readSpeciesIconPaths();
QMap<QString, QString> speciesToIconPath;

1
include/ui/metatileselector.h
View file

@ -48,6 +48,7 @@ private:
void updateSelectedMetatiles();
uint16_t getMetatileId(int x, int y);
QPoint getMetatileIdCoords(uint16_t);
bool shouldAcceptEvent(QGraphicsSceneMouseEvent*);
signals:
void hoveredMetatileSelectionChanged(uint16_t);

4
porymap.pro
View file

@ -30,6 +30,7 @@ SOURCES += src/core/block.cpp \
src/core/tileset.cpp \
src/core/regionmap.cpp \
src/core/wildmoninfo.cpp \
src/lib/orderedjson.cpp \
src/ui/aboutporymap.cpp \
src/ui/bordermetatilespixmapitem.cpp \
src/ui/collisionpixmapitem.cpp \
@ -91,6 +92,8 @@ HEADERS += include/core/block.h \
include/core/tileset.h \
include/core/regionmap.h \
include/core/wildmoninfo.h \
include/lib/orderedmap.h \
include/lib/orderedjson.h \
include/ui/aboutporymap.h \
include/ui/bordermetatilespixmapitem.h \
include/ui/collisionpixmapitem.h \
@ -150,3 +153,4 @@ RESOURCES += \
INCLUDEPATH += include
INCLUDEPATH += include/core
INCLUDEPATH += include/ui
INCLUDEPATH += include/lib

30
src/core/event.cpp
View file

@ -282,7 +282,7 @@ void Event::readCustomValues(QJsonObject values)
}
}
void Event::addCustomValuesTo(QJsonObject *obj)
void Event::addCustomValuesTo(OrderedJson::object *obj)
{
for (QString key : this->customValues.keys()) {
if (!obj->contains(key)) {
@ -291,9 +291,9 @@ void Event::addCustomValuesTo(QJsonObject *obj)
}
}
QJsonObject Event::buildObjectEventJSON()
OrderedJson::object Event::buildObjectEventJSON()
{
QJsonObject eventObj;
OrderedJson::object eventObj;
eventObj["graphics_id"] = this->get("sprite");
if (projectConfig.getBaseGameVersion() == BaseGameVersion::pokefirered) {
eventObj["in_connection"] = this->getInt("in_connection") > 0 || this->get("in_connection") == "TRUE";
@ -313,9 +313,9 @@ QJsonObject Event::buildObjectEventJSON()
return eventObj;
}
QJsonObject Event::buildWarpEventJSON(QMap<QString, QString> *mapNamesToMapConstants)
OrderedJson::object Event::buildWarpEventJSON(QMap<QString, QString> *mapNamesToMapConstants)
{
QJsonObject warpObj;
OrderedJson::object warpObj;
warpObj["x"] = this->getU16("x");
warpObj["y"] = this->getU16("y");
warpObj["elevation"] = this->getInt("elevation");
@ -326,9 +326,9 @@ QJsonObject Event::buildWarpEventJSON(QMap<QString, QString> *mapNamesToMapConst
return warpObj;
}
QJsonObject Event::buildTriggerEventJSON()
OrderedJson::object Event::buildTriggerEventJSON()
{
QJsonObject triggerObj;
OrderedJson::object triggerObj;
triggerObj["type"] = "trigger";
triggerObj["x"] = this->getU16("x");
triggerObj["y"] = this->getU16("y");
@ -341,9 +341,9 @@ QJsonObject Event::buildTriggerEventJSON()
return triggerObj;
}
QJsonObject Event::buildWeatherTriggerEventJSON()
OrderedJson::object Event::buildWeatherTriggerEventJSON()
{
QJsonObject weatherObj;
OrderedJson::object weatherObj;
weatherObj["type"] = "weather";
weatherObj["x"] = this->getU16("x");
weatherObj["y"] = this->getU16("y");
@ -354,9 +354,9 @@ QJsonObject Event::buildWeatherTriggerEventJSON()
return weatherObj;
}
QJsonObject Event::buildSignEventJSON()
OrderedJson::object Event::buildSignEventJSON()
{
QJsonObject signObj;
OrderedJson::object signObj;
signObj["type"] = "sign";
signObj["x"] = this->getU16("x");
signObj["y"] = this->getU16("y");
@ -368,9 +368,9 @@ QJsonObject Event::buildSignEventJSON()
return signObj;
}
QJsonObject Event::buildHiddenItemEventJSON()
OrderedJson::object Event::buildHiddenItemEventJSON()
{
QJsonObject hiddenItemObj;
OrderedJson::object hiddenItemObj;
hiddenItemObj["type"] = "hidden_item";
hiddenItemObj["x"] = this->getU16("x");
hiddenItemObj["y"] = this->getU16("y");
@ -386,9 +386,9 @@ QJsonObject Event::buildHiddenItemEventJSON()
return hiddenItemObj;
}
QJsonObject Event::buildSecretBaseEventJSON()
OrderedJson::object Event::buildSecretBaseEventJSON()
{
QJsonObject secretBaseObj;
OrderedJson::object secretBaseObj;
secretBaseObj["type"] = "secret_base";
secretBaseObj["x"] = this->getU16("x");
secretBaseObj["y"] = this->getU16("y");

13
src/core/tileset.cpp
View file

@ -66,6 +66,19 @@ Metatile* Tileset::getMetatile(int index, Tileset *primaryTileset, Tileset *seco
return metatile;
}
bool Tileset::metatileIsValid(uint16_t metatileId, Tileset *primaryTileset, Tileset *secondaryTileset) {
if (metatileId >= Project::getNumMetatilesTotal())
return false;
if (metatileId < Project::getNumMetatilesPrimary() && metatileId >= primaryTileset->metatiles->length())
return false;
if (metatileId < Project::getNumMetatilesTotal() && metatileId >= Project::getNumMetatilesPrimary() + secondaryTileset->metatiles->length())
return false;
return true;
}
QList<QList<QRgb>> Tileset::getBlockPalettes(Tileset *primaryTileset, Tileset *secondaryTileset) {
QList<QList<QRgb>> palettes;
for (int i = 0; i < Project::getNumPalettesPrimary(); i++) {

760
src/lib/orderedjson.cpp Normal file
View file

@ -0,0 +1,760 @@
/* Copyright (c) 2013 Dropbox, Inc.
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
#include "orderedjson.h"
#include <cassert>
#include <cmath>
#include <cstdlib>
#include <cstdio>
#include <limits>
namespace poryjson {
static const int max_depth = 200;
using std::map;
using std::make_shared;
using std::initializer_list;
using std::move;
/* Helper for representing null - just a do-nothing struct, plus comparison
* operators so the helpers in JsonValue work. We can't use nullptr_t because
* it may not be orderable.
*/
struct NullStruct {
bool operator==(NullStruct) const { return true; }
bool operator<(NullStruct) const { return false; }
};
/* * * * * * * * * * * * * * * * * * * *
* Serialization
*/
static void dump(NullStruct, QString &out, int *indent) {
if (!out.endsWith(": ")) out += QString(*indent * 2, ' ');
out += "null";
}
static void dump(double value, QString &out, int *indent) {
if (!out.endsWith(": ")) out += QString(*indent * 2, ' ');
if (std::isfinite(value)) {
char buf[32];
snprintf(buf, sizeof buf, "%.17g", value);
out += buf;
} else {
out += "null";
}
}
static void dump(int value, QString &out, int *indent) {
if (!out.endsWith(": ")) out += QString(*indent * 2, ' ');
char buf[32];
snprintf(buf, sizeof buf, "%d", value);
out += buf;
}
static void dump(bool value, QString &out, int *indent) {
if (!out.endsWith(": ")) out += QString(*indent * 2, ' ');
out += value ? "true" : "false";
}
static void dump(const QString &value, QString &out, int *indent, bool isKey = false) {
if (!isKey && !out.endsWith(": ")) out += QString(*indent * 2, ' ');
out += '"';
for (int i = 0; i < value.length(); i++) {
const char ch = value[i].unicode();
if (ch == '\\') {
out += "\\\\";
} else if (ch == '"') {
out += "\\\"";
} else if (ch == '\b') {
out += "\\b";
} else if (ch == '\f') {
out += "\\f";
} else if (ch == '\n') {
out += "\\n";
} else if (ch == '\r') {
out += "\\r";
} else if (ch == '\t') {
out += "\\t";
} else if (static_cast<uint8_t>(ch) <= 0x1f) {
char buf[8];
snprintf(buf, sizeof buf, "\\u%04x", ch);
out += buf;
} else if (static_cast<uint8_t>(ch) == 0xe2 && static_cast<uint8_t>(value[i+1].unicode()) == 0x80
&& static_cast<uint8_t>(value[i+2].unicode()) == 0xa8) {
out += "\\u2028";
i += 2;
} else if (static_cast<uint8_t>(ch) == 0xe2 && static_cast<uint8_t>(value[i+1].unicode()) == 0x80
&& static_cast<uint8_t>(value[i+2].unicode()) == 0xa9) {
out += "\\u2029";
i += 2;
} else {
out += ch;
}
}
out += '"';
}
static void dump(const Json::array &values, QString &out, int *indent) {
bool first = true;
if (!out.endsWith(": ")) out += QString(*indent * 2, ' ');
out += "[\n";
*indent += 1;
for (const auto &value : values) {
if (!first) {
out += ",\n";
}
value.dump(out, indent);
first = false;
}
*indent -= 1;
out += "\n" + QString(*indent * 2, ' ') + "]";
}
static void dump(const Json::object &values, QString &out, int *indent) {
bool first = true;
if (!out.endsWith(": ")) out += QString(*indent * 2, ' ');
out += "{\n";
*indent += 1;
for (auto kv : values) {
if (!first) {
out += ",\n";
}
out += QString(*indent * 2, ' ');
dump(kv.first, out, indent, true);
out += ": ";
kv.second.dump(out, indent);
first = false;
}
*indent -= 1;
out += "\n" + QString(*indent * 2, ' ') + "}";
}
void Json::dump(QString &out, int *indent) const {
m_ptr->dump(out, indent);
}
/* * * * * * * * * * * * * * * * * * * *
* Value wrappers
*/
template <Json::Type tag, typename T>
class Value : public JsonValue {
protected:
// Constructors
explicit Value(const T &value) : m_value(value) {}
explicit Value(T &&value) : m_value(move(value)) {}
// Get type tag
Json::Type type() const override {
return tag;
}
// Comparisons
bool equals(const JsonValue * other) const override {
return m_value == static_cast<const Value<tag, T> *>(other)->m_value;
}
bool less(const JsonValue * other) const override {
return m_value < static_cast<const Value<tag, T> *>(other)->m_value;
}
const T m_value;
void dump(QString &out, int *indent) const override { poryjson::dump(m_value, out, indent); }
};
class JsonDouble final : public Value<Json::NUMBER, double> {
double number_value() const override { return m_value; }
int int_value() const override { return static_cast<int>(m_value); }
bool equals(const JsonValue * other) const override { return m_value == other->number_value(); }
bool less(const JsonValue * other) const override { return m_value < other->number_value(); }
public:
explicit JsonDouble(double value) : Value(value) {}
};
class JsonInt final : public Value<Json::NUMBER, int> {
double number_value() const override { return m_value; }
int int_value() const override { return m_value; }
bool equals(const JsonValue * other) const override { return m_value == other->number_value(); }
bool less(const JsonValue * other) const override { return m_value < other->number_value(); }
public:
explicit JsonInt(int value) : Value(value) {}
};
class JsonBoolean final : public Value<Json::BOOL, bool> {
bool bool_value() const override { return m_value; }
public:
explicit JsonBoolean(bool value) : Value(value) {}
};
class JsonString final : public Value<Json::STRING, QString> {
const QString &string_value() const override { return m_value; }
public:
explicit JsonString(const QString &value) : Value(value) {}
explicit JsonString(QString &&value) : Value(move(value)) {}
};
class JsonArray final : public Value<Json::ARRAY, Json::array> {
const Json::array &array_items() const override { return m_value; }
const Json & operator[](int i) const override;
public:
explicit JsonArray(const Json::array &value) : Value(value) {}
explicit JsonArray(Json::array &&value) : Value(move(value)) {}
};
class JsonObject final : public Value<Json::OBJECT, Json::object> {
const Json::object &object_items() const override { return m_value; }
const Json & operator[](const QString &key) const override;
public:
explicit JsonObject(const Json::object &value) : Value(value) {}
explicit JsonObject(Json::object &&value) : Value(move(value)) {}
};
class JsonNull final : public Value<Json::NUL, NullStruct> {
public:
JsonNull() : Value({}) {}
};
/* * * * * * * * * * * * * * * * * * * *
* Static globals - static-init-safe
*/
struct Statics {
const std::shared_ptr<JsonValue> null = make_shared<JsonNull>();
const std::shared_ptr<JsonValue> t = make_shared<JsonBoolean>(true);
const std::shared_ptr<JsonValue> f = make_shared<JsonBoolean>(false);
const QString empty_string;
const QVector<Json> empty_vector;
const Json::object empty_map;
Statics() {}
};
static const Statics & statics() {
static const Statics s {};
return s;
}
static const Json & static_null() {
// This has to be separate, not in Statics, because Json() accesses statics().null.
static const Json json_null;
return json_null;
}
/* * * * * * * * * * * * * * * * * * * *
* Constructors
*/
Json::Json() noexcept : m_ptr(statics().null) {}
Json::Json(std::nullptr_t) noexcept : m_ptr(statics().null) {}
Json::Json(double value) : m_ptr(make_shared<JsonDouble>(value)) {}
Json::Json(int value) : m_ptr(make_shared<JsonInt>(value)) {}
Json::Json(bool value) : m_ptr(value ? statics().t : statics().f) {}
Json::Json(const QString &value) : m_ptr(make_shared<JsonString>(value)) {}
Json::Json(QString &&value) : m_ptr(make_shared<JsonString>(move(value))) {}
Json::Json(const char * value) : m_ptr(make_shared<JsonString>(value)) {}
Json::Json(const Json::array &values) : m_ptr(make_shared<JsonArray>(values)) {}
Json::Json(Json::array &&values) : m_ptr(make_shared<JsonArray>(move(values))) {}
Json::Json(const Json::object &values) : m_ptr(make_shared<JsonObject>(values)) {}
Json::Json(Json::object &&values) : m_ptr(make_shared<JsonObject>(move(values))) {}
/* * * * * * * * * * * * * * * * * * * *
* Accessors
*/
Json::Type Json::type() const { return m_ptr->type(); }
double Json::number_value() const { return m_ptr->number_value(); }
int Json::int_value() const { return m_ptr->int_value(); }
bool Json::bool_value() const { return m_ptr->bool_value(); }
const QString & Json::string_value() const { return m_ptr->string_value(); }
const QVector<Json> & Json::array_items() const { return m_ptr->array_items(); }
const Json::object & Json::object_items() const { return m_ptr->object_items(); }
const Json & Json::operator[] (int i) const { return (*m_ptr)[i]; }
const Json & Json::operator[] (const QString &key) const { return (*m_ptr)[key]; }
double JsonValue::number_value() const { return 0; }
int JsonValue::int_value() const { return 0; }
bool JsonValue::bool_value() const { return false; }
const QString & JsonValue::string_value() const { return statics().empty_string; }
const QVector<Json> & JsonValue::array_items() const { return statics().empty_vector; }
const Json::object & JsonValue::object_items() const { return statics().empty_map; }
const Json & JsonValue::operator[] (int) const { return static_null(); }
const Json & JsonValue::operator[] (const QString &) const { return static_null(); }
const Json & JsonObject::operator[] (const QString &key) const {
static auto iter = m_value.find(key);
return (iter == m_value.end()) ? static_null() : (*iter).second;
}
const Json & JsonArray::operator[] (int i) const {
if (i >= m_value.size()) return static_null();
else return m_value[i];
}
/* * * * * * * * * * * * * * * * * * * *
* Comparison
*/
bool Json::operator== (const Json &other) const {
if (m_ptr == other.m_ptr)
return true;
if (m_ptr->type() != other.m_ptr->type())
return false;
return m_ptr->equals(other.m_ptr.get());
}
bool Json::operator< (const Json &other) const {
if (m_ptr == other.m_ptr)
return false;
if (m_ptr->type() != other.m_ptr->type())
return m_ptr->type() < other.m_ptr->type();
return m_ptr->less(other.m_ptr.get());
}
/* * * * * * * * * * * * * * * * * * * *
* Parsing
*/
/* esc(c)
*
* Format char c suitable for printing in an error message.
*/
static inline QString esc(char c) {
char buf[12];
if (static_cast<uint8_t>(c) >= 0x20 && static_cast<uint8_t>(c) <= 0x7f) {
snprintf(buf, sizeof buf, "'%c' (%d)", c, c);
} else {
snprintf(buf, sizeof buf, "(%d)", c);
}
return QString(buf);
}
static inline bool in_range(long x, long lower, long upper) {
return (x >= lower && x <= upper);
}
namespace {
/* JsonParser
*
* Object that tracks all state of an in-progress parse.
*/
struct JsonParser final {
/* State
*/
const QString &str;
int i;
QString &err;
bool failed;
const JsonParse strategy;
/* fail(msg, err_ret = Json())
*
* Mark this parse as failed.
*/
Json fail(QString &&msg) {
return fail(move(msg), Json());
}
template <typename T>
T fail(QString &&msg, const T err_ret) {
if (!failed)
err = std::move(msg);
failed = true;
return err_ret;
}
/* consume_whitespace()
*
* Advance until the current character is non-whitespace.
*/
void consume_whitespace() {
while (i < str.length() && (str[i] == ' ' || str[i] == '\r' || str[i] == '\n' || str[i] == '\t'))
i++;
}
/* consume_comment()
*
* Advance comments (c-style inline and multiline).
*/
bool consume_comment() {
bool comment_found = false;
if (str[i] == '/') {
i++;
if (i == str.size())
return fail("unexpected end of input after start of comment", false);
if (str[i] == '/') { // inline comment
i++;
// advance until next line, or end of input
while (i < str.size() && str[i] != '\n') {
i++;
}
comment_found = true;
}
else if (str[i] == '*') { // multiline comment
i++;
if (i > str.size()-2)
return fail("unexpected end of input inside multi-line comment", false);
// advance until closing tokens
while (!(str[i] == '*' && str[i+1] == '/')) {
i++;
if (i > str.size()-2)
return fail(
"unexpected end of input inside multi-line comment", false);
}
i += 2;
comment_found = true;
}
else
return fail("malformed comment", false);
}
return comment_found;
}
/* consume_garbage()
*
* Advance until the current character is non-whitespace and non-comment.
*/
void consume_garbage() {
consume_whitespace();
if(strategy == JsonParse::COMMENTS) {
bool comment_found = false;
do {
comment_found = consume_comment();
if (failed) return;
consume_whitespace();
}
while(comment_found);
}
}
/* get_next_token()
*
* Return the next non-whitespace character. If the end of the input is reached,
* flag an error and return 0.
*/
char get_next_token() {
consume_garbage();
if (failed) return static_cast<char>(0);
if (i == str.size())
return fail("unexpected end of input", static_cast<char>(0));
return str[i++].unicode();
}
/* encode_utf8(pt, out)
*
* Encode pt as UTF-8 and add it to out.
*/
void encode_utf8(long pt, QString & out) {
if (pt < 0)
return;
if (pt < 0x80) {
out += static_cast<char>(pt);
} else if (pt < 0x800) {
out += static_cast<char>((pt >> 6) | 0xC0);
out += static_cast<char>((pt & 0x3F) | 0x80);
} else if (pt < 0x10000) {
out += static_cast<char>((pt >> 12) | 0xE0);
out += static_cast<char>(((pt >> 6) & 0x3F) | 0x80);
out += static_cast<char>((pt & 0x3F) | 0x80);
} else {
out += static_cast<char>((pt >> 18) | 0xF0);
out += static_cast<char>(((pt >> 12) & 0x3F) | 0x80);
out += static_cast<char>(((pt >> 6) & 0x3F) | 0x80);
out += static_cast<char>((pt & 0x3F) | 0x80);
}
}
/* parse_string()
*
* Parse a QString, starting at the current position.
*/
QString parse_string() {
QString out;
long last_escaped_codepoint = -1;
while (true) {
if (i == str.size())
return fail("unexpected end of input in QString", "");
char ch = str[i++].unicode();
if (ch == '"') {
encode_utf8(last_escaped_codepoint, out);
return out;
}
if (in_range(ch, 0, 0x1f))
return fail(QString("unescaped " + esc(ch) + " in QString"), QString());
// The usual case: non-escaped characters
if (ch != '\\') {
encode_utf8(last_escaped_codepoint, out);
last_escaped_codepoint = -1;
out += ch;
continue;
}
// Handle escapes
if (i == str.size())
return fail("unexpected end of input in QString", "");
ch = str[i++].unicode();
if (ch == 'u') {
// Extract 4-byte escape sequence
QString esc = str.right(i).left(4);
// Explicitly check length of the substring. The following loop
// relies on std::QString returning the terminating NUL when
// accessing str[length]. Checking here reduces brittleness.
if (esc.length() < 4) {
return fail(QString("bad \\u escape: " + esc), "");
}
for (unsigned j = 0; j < 4; j++) {
if (!in_range(esc[j].unicode(), 'a', 'f') && !in_range(esc[j].unicode(), 'A', 'F')
&& !in_range(esc[j].unicode(), '0', '9'))
return fail(QString("bad \\u escape: " + esc), "");
}
long codepoint = esc.toLong(nullptr, 16);
// JSON specifies that characters outside the BMP shall be encoded as a pair
// of 4-hex-digit \u escapes encoding their surrogate pair components. Check
// whether we're in the middle of such a beast: the previous codepoint was an
// escaped lead (high) surrogate, and this is a trail (low) surrogate.
if (in_range(last_escaped_codepoint, 0xD800, 0xDBFF)
&& in_range(codepoint, 0xDC00, 0xDFFF)) {
// Reassemble the two surrogate pairs into one astral-plane character, per
// the UTF-16 algorithm.
encode_utf8((((last_escaped_codepoint - 0xD800) << 10)
| (codepoint - 0xDC00)) + 0x10000, out);
last_escaped_codepoint = -1;
} else {
encode_utf8(last_escaped_codepoint, out);
last_escaped_codepoint = codepoint;
}
i += 4;
continue;
}
encode_utf8(last_escaped_codepoint, out);
last_escaped_codepoint = -1;
if (ch == 'b') {
out += '\b';
} else if (ch == 'f') {
out += '\f';
} else if (ch == 'n') {
out += '\n';
} else if (ch == 'r') {
out += '\r';
} else if (ch == 't') {
out += '\t';
} else if (ch == '"' || ch == '\\' || ch == '/') {
out += ch;
} else {
return fail(QString("invalid escape character " + esc(ch)), "");
}
}
}
/* parse_number()
*
* Parse a double.
*/
Json parse_number() {
unsigned start_pos = i;
if (str[i] == '-')
i++;
// Integer part
if (str[i] == '0') {
i++;
if (in_range(str[i].unicode(), '0', '9'))
return fail("leading 0s not permitted in numbers");
} else if (in_range(str[i].unicode(), '1', '9')) {
i++;
while (in_range(str[i].unicode(), '0', '9'))
i++;
} else {
return fail(QString("invalid " + esc(str[i].unicode()) + " in number"));
}
if (str[i] != '.' && str[i] != 'e' && str[i] != 'E'
&& (i - start_pos) <= static_cast<unsigned>(std::numeric_limits<int>::digits10)) {
return std::atoi(str.toStdString().c_str() + start_pos);
}
// Decimal part
if (str[i] == '.') {
i++;
if (!in_range(str[i].unicode(), '0', '9'))
return fail("at least one digit required in fractional part");
while (in_range(str[i].unicode(), '0', '9'))
i++;
}
// Exponent part
if (str[i] == 'e' || str[i] == 'E') {
i++;
if (str[i] == '+' || str[i] == '-')
i++;
if (!in_range(str[i].unicode(), '0', '9'))
return fail("at least one digit required in exponent");
while (in_range(str[i].unicode(), '0', '9'))
i++;
}
return std::strtod(str.toStdString().c_str() + start_pos, nullptr);
}
/* expect(str, res)
*
* Expect that 'str' starts at the character that was just read. If it does, advance
* the input and return res. If not, flag an error.
*/
Json expect(const QString &expected, Json res) {
assert(i != 0);
i--;
QString result = str.right(str.size() - i).left(expected.length());
if (result == expected) {
i += expected.length();
return res;
} else {
return fail(QString("parse error: expected " + expected + ", got " + str.right(i).left(expected.length())));
}
}
/* parse_json()
*
* Parse a JSON object.
*/
Json parse_json(int depth) {
if (depth > max_depth) {
return fail("exceeded maximum nesting depth");
}
char ch = get_next_token();
if (failed)
return Json();
if (ch == '-' || (ch >= '0' && ch <= '9')) {
i--;
return parse_number();
}
if (ch == 't')
return expect("true", true);
if (ch == 'f')
return expect("false", false);
if (ch == 'n')
return expect("null", Json());
if (ch == '"')
return parse_string();
if (ch == '{') {
Json::object data;
ch = get_next_token();
if (ch == '}')
return data;
while (1) {
if (ch != '"')
return fail(QString("expected '\"' in object, got " + esc(ch)));
QString key = parse_string();
if (failed)
return Json();
ch = get_next_token();
if (ch != ':')
return fail(QString("expected ':' in object, got " + esc(ch)));
data[std::move(key)] = parse_json(depth + 1);
if (failed)
return Json();
ch = get_next_token();
if (ch == '}')
break;
if (ch != ',')
return fail(QString("expected ',' in object, got " + esc(ch)));
ch = get_next_token();
}
return data;
}
if (ch == '[') {
QVector<Json> data;
ch = get_next_token();
if (ch == ']')
return data;
while (1) {
i--;
data.push_back(parse_json(depth + 1));
if (failed)
return Json();
ch = get_next_token();
if (ch == ']')
break;
if (ch != ',')
return fail(QString("expected ',' in list, got " + esc(ch)));
ch = get_next_token();
(void)ch;
}
return data;
}
return fail(QString("expected value, got " + esc(ch)));
}
};
}//namespace {
Json Json::parse(const QString &in, QString &err, JsonParse strategy) {
JsonParser parser { in, 0, err, false, strategy };
Json result = parser.parse_json(0);
// Check for any trailing garbage
parser.consume_garbage();
if (parser.failed)
return Json();
if (parser.i != in.size())
return parser.fail(QString("unexpected trailing " + esc(in[parser.i].unicode())));
return result;
}
} // namespace poryjson

125
src/project.cpp
View file

@ -10,6 +10,8 @@
#include "imageexport.h"
#include "map.h"
#include "orderedjson.h"
#include <QDir>
#include <QJsonArray>
#include <QJsonDocument>
@ -22,6 +24,9 @@
#include <QRegularExpression>
#include <algorithm>
using OrderedJson = poryjson::Json;
using OrderedJsonDoc = poryjson::JsonDoc;
int Project::num_tiles_primary = 512;
int Project::num_tiles_total = 1024;
int Project::num_metatiles_primary = 512;
@ -592,14 +597,14 @@ void Project::saveMapLayouts() {
return;
}
QJsonObject layoutsObj;
OrderedJson::object layoutsObj;
layoutsObj["layouts_table_label"] = layoutsLabel;
bool useCustomBorderSize = projectConfig.getUseCustomBorderSize();
QJsonArray layoutsArr;
OrderedJson::array layoutsArr;
for (QString layoutId : mapLayoutsTableMaster) {
MapLayout *layout = mapLayouts.value(layoutId);
QJsonObject layoutObj;
OrderedJson::object layoutObj;
layoutObj["id"] = layout->id;
layoutObj["name"] = layout->name;
layoutObj["width"] = layout->width.toInt(nullptr, 0);
@ -612,12 +617,14 @@ void Project::saveMapLayouts() {
layoutObj["secondary_tileset"] = layout->tileset_secondary_label;
layoutObj["border_filepath"] = layout->border_path;
layoutObj["blockdata_filepath"] = layout->blockdata_path;
layoutsArr.append(layoutObj);
layoutsArr.push_back(layoutObj);
}
layoutsObj["layouts"] = layoutsArr;
QJsonDocument layoutsDoc(layoutsObj);
layoutsFile.write(layoutsDoc.toJson());
OrderedJson layoutJson(layoutsObj);
OrderedJsonDoc jsonDoc(&layoutJson);
jsonDoc.dump(&layoutsFile);
layoutsFile.close();
}
void Project::setNewMapLayout(Map* map) {
@ -648,27 +655,29 @@ void Project::saveMapGroups() {
return;
}
QJsonObject mapGroupsObj;
OrderedJson::object mapGroupsObj;
mapGroupsObj["layouts_table_label"] = layoutsLabel;
QJsonArray groupNamesArr;
OrderedJson::array groupNamesArr;
for (QString groupName : *this->groupNames) {
groupNamesArr.append(groupName);
groupNamesArr.push_back(groupName);
}
mapGroupsObj["group_order"] = groupNamesArr;
int groupNum = 0;
for (QStringList mapNames : groupedMapNames) {
QJsonArray groupArr;
OrderedJson::array groupArr;
for (QString mapName : mapNames) {
groupArr.append(mapName);
groupArr.push_back(mapName);
}
mapGroupsObj[this->groupNames->at(groupNum)] = groupArr;
groupNum++;
}
QJsonDocument mapGroupsDoc(mapGroupsObj);
mapGroupsFile.write(mapGroupsDoc.toJson());
OrderedJson mapGroupJson(mapGroupsObj);
OrderedJsonDoc jsonDoc(&mapGroupJson);
jsonDoc.dump(&mapGroupsFile);
mapGroupsFile.close();
}
void Project::saveWildMonData() {
@ -681,78 +690,79 @@ void Project::saveWildMonData() {
return;
}
QJsonObject wildEncountersObject;
QJsonArray wildEncounterGroups = QJsonArray();
OrderedJson::object wildEncountersObject;
OrderedJson::array wildEncounterGroups;
// gWildMonHeaders label is not mutable
QJsonObject monHeadersObject;
OrderedJson::object monHeadersObject;
monHeadersObject["label"] = "gWildMonHeaders";
monHeadersObject["for_maps"] = true;
QJsonArray fieldsInfoArray;
OrderedJson::array fieldsInfoArray;
for (EncounterField fieldInfo : wildMonFields) {
QJsonObject fieldObject;
QJsonArray rateArray;
OrderedJson::object fieldObject;
OrderedJson::array rateArray;
for (int rate : fieldInfo.encounterRates) {
rateArray.append(rate);
rateArray.push_back(rate);
}
fieldObject["type"] = fieldInfo.name;
fieldObject["encounter_rates"] = rateArray;
QJsonObject groupsObject;
OrderedJson::object groupsObject;
for (QString groupName : fieldInfo.groups.keys()) {
QJsonArray subGroupIndices;
OrderedJson::array subGroupIndices;
std::sort(fieldInfo.groups[groupName].begin(), fieldInfo.groups[groupName].end());
for (int slotIndex : fieldInfo.groups[groupName]) {
subGroupIndices.append(slotIndex);
subGroupIndices.push_back(slotIndex);
}
groupsObject[groupName] = subGroupIndices;
}
if (!groupsObject.isEmpty()) fieldObject["groups"] = groupsObject;
if (!groupsObject.empty()) fieldObject["groups"] = groupsObject;
fieldsInfoArray.append(fieldObject);
}
monHeadersObject["fields"] = fieldsInfoArray;
QJsonArray encountersArray = QJsonArray();
OrderedJson::array encountersArray;
for (QString key : wildMonData.keys()) {
for (QString groupLabel : wildMonData.value(key).keys()) {
QJsonObject encounterObject;
OrderedJson::object encounterObject;
encounterObject["map"] = key;
encounterObject["base_label"] = groupLabel;
WildPokemonHeader encounterHeader = wildMonData.value(key).value(groupLabel);
for (QString fieldName : encounterHeader.wildMons.keys()) {
QJsonObject fieldObject;
OrderedJson::object fieldObject;
WildMonInfo monInfo = encounterHeader.wildMons.value(fieldName);
fieldObject["encounter_rate"] = monInfo.encounterRate;
QJsonArray monArray;
OrderedJson::array monArray;
for (WildPokemon wildMon : monInfo.wildPokemon) {
QJsonObject monEntry;
OrderedJson::object monEntry;
monEntry["min_level"] = wildMon.minLevel;
monEntry["max_level"] = wildMon.maxLevel;
monEntry["species"] = wildMon.species;
monArray.append(monEntry);
monArray.push_back(monEntry);
}
fieldObject["mons"] = monArray;
encounterObject[fieldName] = fieldObject;
}
encountersArray.append(encounterObject);
encountersArray.push_back(encounterObject);
}
}
monHeadersObject["encounters"] = encountersArray;
wildEncounterGroups.append(monHeadersObject);
wildEncounterGroups.push_back(monHeadersObject);
// add extra Json objects that are not associated with maps to the file
for (QString label : extraEncounterGroups.keys()) {
wildEncounterGroups.append(extraEncounterGroups[label]);
for (auto extraObject : extraEncounterGroups) {
wildEncounterGroups.push_back(extraObject);
}
wildEncountersObject["wild_encounter_groups"] = wildEncounterGroups;
QJsonDocument wildEncountersDoc(wildEncountersObject);
wildEncountersFile.write(wildEncountersDoc.toJson());
OrderedJson encounterJson(wildEncountersObject);
OrderedJsonDoc jsonDoc(&encounterJson);
jsonDoc.dump(&wildEncountersFile);
wildEncountersFile.close();
}
@ -1263,7 +1273,7 @@ void Project::saveMap(Map *map) {
return;
}
QJsonObject mapObj;
OrderedJson::object mapObj;
// Header values.
mapObj["id"] = map->constantName;
mapObj["name"] = map->name;
@ -1284,10 +1294,10 @@ void Project::saveMap(Map *map) {
// Connections
if (map->connections.length() > 0) {
QJsonArray connectionsArr;
OrderedJson::array connectionsArr;
for (MapConnection* connection : map->connections) {
if (mapNamesToMapConstants->contains(connection->map_name)) {
QJsonObject connectionObj;
OrderedJson::object connectionObj;
connectionObj["direction"] = connection->direction;
connectionObj["offset"] = connection->offset.toInt();
connectionObj["map"] = this->mapNamesToMapConstants->value(connection->map_name);
@ -1303,51 +1313,51 @@ void Project::saveMap(Map *map) {
if (map->sharedEventsMap.isEmpty()) {
// Object events
QJsonArray objectEventsArr;
OrderedJson::array objectEventsArr;
for (int i = 0; i < map->events["object_event_group"].length(); i++) {
Event *object_event = map->events["object_event_group"].value(i);
QJsonObject eventObj = object_event->buildObjectEventJSON();
objectEventsArr.append(eventObj);
OrderedJson::object eventObj = object_event->buildObjectEventJSON();
objectEventsArr.push_back(eventObj);
}
mapObj["object_events"] = objectEventsArr;
// Warp events
QJsonArray warpEventsArr;
OrderedJson::array warpEventsArr;
for (int i = 0; i < map->events["warp_event_group"].length(); i++) {
Event *warp_event = map->events["warp_event_group"].value(i);
QJsonObject warpObj = warp_event->buildWarpEventJSON(mapNamesToMapConstants);
OrderedJson::object warpObj = warp_event->buildWarpEventJSON(mapNamesToMapConstants);
warpEventsArr.append(warpObj);
}
mapObj["warp_events"] = warpEventsArr;
// Coord events
QJsonArray coordEventsArr;
OrderedJson::array coordEventsArr;
for (int i = 0; i < map->events["coord_event_group"].length(); i++) {
Event *event = map->events["coord_event_group"].value(i);
QString event_type = event->get("event_type");
if (event_type == EventType::Trigger) {
QJsonObject triggerObj = event->buildTriggerEventJSON();
OrderedJson::object triggerObj = event->buildTriggerEventJSON();
coordEventsArr.append(triggerObj);
} else if (event_type == EventType::WeatherTrigger) {
QJsonObject weatherObj = event->buildWeatherTriggerEventJSON();
OrderedJson::object weatherObj = event->buildWeatherTriggerEventJSON();
coordEventsArr.append(weatherObj);
}
}
mapObj["coord_events"] = coordEventsArr;
// Bg Events
QJsonArray bgEventsArr;
OrderedJson::array bgEventsArr;
for (int i = 0; i < map->events["bg_event_group"].length(); i++) {
Event *event = map->events["bg_event_group"].value(i);
QString event_type = event->get("event_type");
if (event_type == EventType::Sign) {
QJsonObject signObj = event->buildSignEventJSON();
OrderedJson::object signObj = event->buildSignEventJSON();
bgEventsArr.append(signObj);
} else if (event_type == EventType::HiddenItem) {
QJsonObject hiddenItemObj = event->buildHiddenItemEventJSON();
OrderedJson::object hiddenItemObj = event->buildHiddenItemEventJSON();
bgEventsArr.append(hiddenItemObj);
} else if (event_type == EventType::SecretBase) {
QJsonObject secretBaseObj = event->buildSecretBaseEventJSON();
OrderedJson::object secretBaseObj = event->buildSecretBaseEventJSON();
bgEventsArr.append(secretBaseObj);
}
}
@ -1365,8 +1375,9 @@ void Project::saveMap(Map *map) {
mapObj[key] = map->customHeaders[key];
}
QJsonDocument mapDoc(mapObj);
mapFile.write(mapDoc.toJson());
OrderedJson mapJson(mapObj);
OrderedJsonDoc jsonDoc(&mapJson);
jsonDoc.dump(&mapFile);
mapFile.close();
saveLayoutBorder(map);
@ -1690,7 +1701,13 @@ bool Project::readWildMonData() {
for (auto subObjectRef : wildMonObj["wild_encounter_groups"].toArray()) {
QJsonObject subObject = subObjectRef.toObject();
if (!subObject["for_maps"].toBool()) {
extraEncounterGroups.insert(subObject["label"].toString(), subObject);
QString err;
QString subObjson = QJsonDocument(subObject).toJson();
OrderedJson::object orderedSubObject = OrderedJson::parse(subObjson, err).object_items();
extraEncounterGroups.push_back(orderedSubObject);
if (!err.isEmpty()) {
logWarn(QString("Encountered a problem while parsing extra encounter groups: %1").arg(err));
}
continue;
}

4
src/ui/imageproviders.cpp
View file

@ -18,13 +18,13 @@ QImage getMetatileImage(uint16_t tile, Tileset *primaryTileset, Tileset *seconda
Metatile* metatile = Tileset::getMetatile(tile, primaryTileset, secondaryTileset);
if (!metatile || !metatile->tiles) {
metatile_image.fill(0xffffffff);
metatile_image.fill(Qt::magenta);
return metatile_image;
}
Tileset* blockTileset = Tileset::getBlockTileset(tile, primaryTileset, secondaryTileset);
if (!blockTileset) {
metatile_image.fill(0xffffffff);
metatile_image.fill(Qt::magenta);
return metatile_image;
}
QList<QList<QRgb>> palettes = Tileset::getBlockPalettes(primaryTileset, secondaryTileset);

13
src/ui/metatileselector.cpp
View file

@ -24,6 +24,7 @@ void MetatileSelector::draw() {
height_++;
}
QImage image(this->numMetatilesWide * 16, height_ * 16, QImage::Format_RGBA8888);
image.fill(Qt::magenta);
QPainter painter(&image);
for (int i = 0; i < length_; i++) {
int tile = i;
@ -91,13 +92,20 @@ void MetatileSelector::setExternalSelection(int width, int height, QList<uint16_
emit selectedMetatilesChanged();
}
bool MetatileSelector::shouldAcceptEvent(QGraphicsSceneMouseEvent *event) {
QPoint pos = this->getCellPos(event->pos());
return Tileset::metatileIsValid(getMetatileId(pos.x(), pos.y()), this->primaryTileset, this->secondaryTileset);
}
void MetatileSelector::mousePressEvent(QGraphicsSceneMouseEvent *event) {
if (!shouldAcceptEvent(event)) return;
SelectablePixmapItem::mousePressEvent(event);
this->updateSelectedMetatiles();
emit selectedMetatilesChanged();
}
void MetatileSelector::mouseMoveEvent(QGraphicsSceneMouseEvent *event) {
if (!shouldAcceptEvent(event)) return;
SelectablePixmapItem::mouseMoveEvent(event);
this->updateSelectedMetatiles();
@ -108,6 +116,7 @@ void MetatileSelector::mouseMoveEvent(QGraphicsSceneMouseEvent *event) {
}
void MetatileSelector::mouseReleaseEvent(QGraphicsSceneMouseEvent *event) {
if (!shouldAcceptEvent(event)) return;
SelectablePixmapItem::mouseReleaseEvent(event);
this->updateSelectedMetatiles();
emit selectedMetatilesChanged();
@ -147,9 +156,7 @@ uint16_t MetatileSelector::getMetatileId(int x, int y) {
}
QPoint MetatileSelector::getMetatileIdCoords(uint16_t metatileId) {
if (metatileId >= Project::getNumMetatilesTotal()
|| (metatileId < Project::getNumMetatilesPrimary() && metatileId >= this->primaryTileset->metatiles->length())
|| (metatileId < Project::getNumMetatilesTotal() && metatileId >= Project::getNumMetatilesPrimary() + this->secondaryTileset->metatiles->length()))
if (!Tileset::metatileIsValid(metatileId, this->primaryTileset, this->secondaryTileset))
{
// Invalid metatile id.
return QPoint(0, 0);

1
src/ui/montabwidget.cpp
View file

@ -30,6 +30,7 @@ void MonTabWidget::populate() {
table->setEditTriggers(QAbstractItemView::NoEditTriggers);
table->setFocusPolicy(Qt::NoFocus);
table->setSelectionMode(QAbstractItemView::NoSelection);
table->setTabKeyNavigation(false);
table->clearFocus();
addTab(table, field.name);
}