Merge branch 'master' into pokefirered

.gitignore

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

include/core/event.h

@@ -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();
+    OrderedJson::object buildObjectEventJSON();
-    QJsonObject buildWarpEventJSON(QMap<QString, QString>*);
+    OrderedJson::object buildWarpEventJSON(QMap<QString, QString>*);
-    QJsonObject buildTriggerEventJSON();
+    OrderedJson::object buildTriggerEventJSON();
-    QJsonObject buildWeatherTriggerEventJSON();
+    OrderedJson::object buildWeatherTriggerEventJSON();
-    QJsonObject buildSignEventJSON();
+    OrderedJson::object buildSignEventJSON();
-    QJsonObject buildHiddenItemEventJSON();
+    OrderedJson::object buildHiddenItemEventJSON();
-    QJsonObject buildSecretBaseEventJSON();
+    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;

include/core/tileset.h

@@ -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);

include/lib/orderedjson.h

@@ -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
+

include/project.h

@@ -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;

include/ui/metatileselector.h

@@ -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);

porymap.pro

@@ -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

src/core/event.cpp

@@ -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");

src/core/tileset.cpp

@@ -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++) {

src/lib/orderedjson.cpp

@@ -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

src/project.cpp

@@ -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);
+    OrderedJson layoutJson(layoutsObj);
-    layoutsFile.write(layoutsDoc.toJson());
+    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);
+    OrderedJson mapGroupJson(mapGroupsObj);
-    mapGroupsFile.write(mapGroupsDoc.toJson());
+    OrderedJsonDoc jsonDoc(&mapGroupJson);
+    jsonDoc.dump(&mapGroupsFile);
+    mapGroupsFile.close();
 }
 
 void Project::saveWildMonData() {
@@ -681,78 +690,79 @@ void Project::saveWildMonData() {
         return;
     }
 
-    QJsonObject wildEncountersObject;
+    OrderedJson::object wildEncountersObject;
-    QJsonArray wildEncounterGroups = QJsonArray();
+    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;
+        OrderedJson::object fieldObject;
-        QJsonArray rateArray;
+        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()) {
+    for (auto extraObject : extraEncounterGroups) {
-        wildEncounterGroups.append(extraEncounterGroups[label]);
+        wildEncounterGroups.push_back(extraObject);
     }
 
     wildEncountersObject["wild_encounter_groups"] = wildEncounterGroups;
-    QJsonDocument wildEncountersDoc(wildEncountersObject);
+    OrderedJson encounterJson(wildEncountersObject);
-    wildEncountersFile.write(wildEncountersDoc.toJson());
+    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();
+            OrderedJson::object eventObj = object_event->buildObjectEventJSON();
-            objectEventsArr.append(eventObj);
+            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);
+    OrderedJson mapJson(mapObj);
-    mapFile.write(mapDoc.toJson());
+    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;
         }
 

src/ui/imageproviders.cpp

@@ -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);

src/ui/metatileselector.cpp

@@ -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()
+    if (!Tileset::metatileIsValid(metatileId, this->primaryTileset, this->secondaryTileset))
-       || (metatileId < Project::getNumMetatilesPrimary() && metatileId >= this->primaryTileset->metatiles->length())
-       || (metatileId < Project::getNumMetatilesTotal() && metatileId >= Project::getNumMetatilesPrimary() + this->secondaryTileset->metatiles->length()))
     {
         // Invalid metatile id.
         return QPoint(0, 0);

src/ui/montabwidget.cpp

@@ -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);
     }