Move cards and filters folder out of game (#6145)

* big move

* also move game_specific_terms

* fix imports

* alphabetize cmake

* fix build failure

* create database folder and move files into it

* fix includes

* run formatter

cockatrice/src/database/parser/card_database_parser.cpp

@@ -0,0 +1,29 @@
+#include "card_database_parser.h"
+
+SetNameMap ICardDatabaseParser::sets;
+
+void ICardDatabaseParser::clearSetlist()
+{
+    sets.clear();
+}
+
+CardSetPtr ICardDatabaseParser::internalAddSet(const QString &setName,
+                                               const QString &longName,
+                                               const QString &setType,
+                                               const QDate &releaseDate,
+                                               const CardSet::Priority priority)
+{
+    if (sets.contains(setName)) {
+        return sets.value(setName);
+    }
+
+    CardSetPtr newSet = CardSet::newInstance(setName);
+    newSet->setLongName(longName);
+    newSet->setSetType(setType);
+    newSet->setReleaseDate(releaseDate);
+    newSet->setPriority(priority);
+
+    sets.insert(setName, newSet);
+    emit addSet(newSet);
+    return newSet;
+}

cockatrice/src/database/parser/card_database_parser.h

@@ -0,0 +1,45 @@
+#ifndef CARDDATABASE_PARSER_H
+#define CARDDATABASE_PARSER_H
+
+#include "../../card/card_info.h"
+
+#include <QIODevice>
+#include <QString>
+
+#define COCKATRICE_XML_XSI_NAMESPACE "http://www.w3.org/2001/XMLSchema-instance"
+
+class ICardDatabaseParser : public QObject
+{
+    Q_OBJECT
+public:
+    ~ICardDatabaseParser() override = default;
+
+    virtual bool getCanParseFile(const QString &name, QIODevice &device) = 0;
+    virtual void parseFile(QIODevice &device) = 0;
+    virtual bool saveToFile(SetNameMap sets,
+                            CardNameMap cards,
+                            const QString &fileName,
+                            const QString &sourceUrl = "unknown",
+                            const QString &sourceVersion = "unknown") = 0;
+    static void clearSetlist();
+
+protected:
+    /*
+     * A cached list of the available sets, needed to cross-reference sets from cards.
+     * Shared between all parsers
+     */
+    static SetNameMap sets;
+
+    CardSetPtr internalAddSet(const QString &setName,
+                              const QString &longName = "",
+                              const QString &setType = "",
+                              const QDate &releaseDate = QDate(),
+                              const CardSet::Priority priority = CardSet::PriorityFallback);
+signals:
+    void addCard(CardInfoPtr card);
+    void addSet(CardSetPtr set);
+};
+
+Q_DECLARE_INTERFACE(ICardDatabaseParser, "ICardDatabaseParser")
+
+#endif

cockatrice/src/database/parser/cockatrice_xml_3.cpp

@@ -0,0 +1,480 @@
+#include "cockatrice_xml_3.h"
+
+#include <QCoreApplication>
+#include <QDebug>
+#include <QFile>
+#include <QXmlStreamReader>
+#include <version_string.h>
+
+#define COCKATRICE_XML3_TAGNAME "cockatrice_carddatabase"
+#define COCKATRICE_XML3_TAGVER 3
+#define COCKATRICE_XML3_SCHEMALOCATION                                                                                 \
+    "https://raw.githubusercontent.com/Cockatrice/Cockatrice/master/doc/carddatabase_v3/cards.xsd"
+
+bool CockatriceXml3Parser::getCanParseFile(const QString &fileName, QIODevice &device)
+{
+    qCInfo(CockatriceXml3Log) << "Trying to parse: " << fileName;
+
+    if (!fileName.endsWith(".xml", Qt::CaseInsensitive)) {
+        qCInfo(CockatriceXml3Log) << "Parsing failed: wrong extension";
+        return false;
+    }
+
+    QXmlStreamReader xml(&device);
+    while (!xml.atEnd()) {
+        if (xml.readNext() == QXmlStreamReader::StartElement) {
+            if (xml.name().toString() == COCKATRICE_XML3_TAGNAME) {
+                int version = xml.attributes().value("version").toString().toInt();
+                if (version == COCKATRICE_XML3_TAGVER) {
+                    return true;
+                } else {
+                    qCInfo(CockatriceXml3Log) << "Parsing failed: wrong version" << version;
+                    return false;
+                }
+
+            } else {
+                qCInfo(CockatriceXml3Log) << "Parsing failed: wrong element tag" << xml.name();
+                return false;
+            }
+        }
+    }
+
+    return true;
+}
+
+void CockatriceXml3Parser::parseFile(QIODevice &device)
+{
+    QXmlStreamReader xml(&device);
+    while (!xml.atEnd()) {
+        if (xml.readNext() == QXmlStreamReader::StartElement) {
+            while (!xml.atEnd()) {
+                if (xml.readNext() == QXmlStreamReader::EndElement) {
+                    break;
+                }
+
+                auto name = xml.name().toString();
+                if (name == "sets") {
+                    loadSetsFromXml(xml);
+                } else if (name == "cards") {
+                    loadCardsFromXml(xml);
+                } else if (!name.isEmpty()) {
+                    qCInfo(CockatriceXml3Log) << "Unknown item" << name << ", trying to continue anyway";
+                    xml.skipCurrentElement();
+                }
+            }
+        }
+    }
+
+    if (xml.hasError()) {
+        QString preamble = tr("Parse error at line %1 col %2:").arg(xml.lineNumber()).arg(xml.columnNumber());
+        qCWarning(CockatriceXml3Log).noquote() << preamble << xml.errorString();
+    }
+}
+
+void CockatriceXml3Parser::loadSetsFromXml(QXmlStreamReader &xml)
+{
+    while (!xml.atEnd()) {
+        if (xml.readNext() == QXmlStreamReader::EndElement) {
+            break;
+        }
+
+        auto name = xml.name().toString();
+        if (name == "set") {
+            QString shortName, longName, setType;
+            QDate releaseDate;
+            while (!xml.atEnd()) {
+                if (xml.readNext() == QXmlStreamReader::EndElement) {
+                    break;
+                }
+                name = xml.name().toString();
+
+                if (name == "name") {
+                    shortName = xml.readElementText(QXmlStreamReader::IncludeChildElements);
+                } else if (name == "longname") {
+                    longName = xml.readElementText(QXmlStreamReader::IncludeChildElements);
+                } else if (name == "settype") {
+                    setType = xml.readElementText(QXmlStreamReader::IncludeChildElements);
+                } else if (name == "releasedate") {
+                    releaseDate =
+                        QDate::fromString(xml.readElementText(QXmlStreamReader::IncludeChildElements), Qt::ISODate);
+                } else if (!name.isEmpty()) {
+                    qCInfo(CockatriceXml3Log) << "Unknown set property" << name << ", trying to continue anyway";
+                    xml.skipCurrentElement();
+                }
+            }
+
+            internalAddSet(shortName, longName, setType, releaseDate);
+        }
+    }
+}
+
+QString CockatriceXml3Parser::getMainCardType(QString &type)
+{
+    QString result = type;
+    /*
+    Legendary Artifact Creature - Golem
+    Instant // Instant
+    */
+
+    int pos;
+    if ((pos = result.indexOf('-')) != -1) {
+        result.remove(pos, result.length());
+    }
+
+    if ((pos = result.indexOf("—")) != -1) {
+        result.remove(pos, result.length());
+    }
+
+    if ((pos = result.indexOf("//")) != -1) {
+        result.remove(pos, result.length());
+    }
+
+    result = result.simplified();
+    /*
+    Legendary Artifact Creature
+    Instant
+    */
+
+    if ((pos = result.lastIndexOf(' ')) != -1) {
+        result = result.mid(pos + 1);
+    }
+    /*
+    Creature
+    Instant
+    */
+
+    return result;
+}
+
+void CockatriceXml3Parser::loadCardsFromXml(QXmlStreamReader &xml)
+{
+    while (!xml.atEnd()) {
+        if (xml.readNext() == QXmlStreamReader::EndElement) {
+            break;
+        }
+
+        auto xmlName = xml.name().toString();
+        if (xmlName == "card") {
+            QString name = QString("");
+            QString text = QString("");
+            QVariantHash properties = QVariantHash();
+            QString colors = QString("");
+            QList<CardRelation *> relatedCards, reverseRelatedCards;
+            auto _sets = SetToPrintingsMap();
+            int tableRow = 0;
+            bool cipt = false;
+            bool landscapeOrientation = false;
+            bool isToken = false;
+            bool upsideDown = false;
+
+            while (!xml.atEnd()) {
+                if (xml.readNext() == QXmlStreamReader::EndElement) {
+                    break;
+                }
+                xmlName = xml.name().toString();
+
+                // variable - assigned properties
+                if (xmlName == "name") {
+                    name = xml.readElementText(QXmlStreamReader::IncludeChildElements);
+                } else if (xmlName == "text") {
+                    text = xml.readElementText(QXmlStreamReader::IncludeChildElements);
+                } else if (xmlName == "color" || xmlName == "colors") {
+                    colors.append(xml.readElementText(QXmlStreamReader::IncludeChildElements));
+                } else if (xmlName == "token") {
+                    isToken = static_cast<bool>(xml.readElementText(QXmlStreamReader::IncludeChildElements).toInt());
+                    // generic properties
+                } else if (xmlName == "manacost") {
+                    properties.insert("manacost", xml.readElementText(QXmlStreamReader::IncludeChildElements));
+                } else if (xmlName == "cmc") {
+                    properties.insert("cmc", xml.readElementText(QXmlStreamReader::IncludeChildElements));
+                } else if (xmlName == "type") {
+                    QString type = xml.readElementText(QXmlStreamReader::IncludeChildElements);
+                    properties.insert("type", type);
+                    properties.insert("maintype", getMainCardType(type));
+                } else if (xmlName == "pt") {
+                    properties.insert("pt", xml.readElementText(QXmlStreamReader::IncludeChildElements));
+                } else if (xmlName == "loyalty") {
+                    properties.insert("loyalty", xml.readElementText(QXmlStreamReader::IncludeChildElements));
+                    // positioning info
+                } else if (xmlName == "tablerow") {
+                    tableRow = xml.readElementText(QXmlStreamReader::IncludeChildElements).toInt();
+                } else if (xmlName == "cipt") {
+                    cipt = (xml.readElementText(QXmlStreamReader::IncludeChildElements) == "1");
+                } else if (xmlName == "landscapeOrientation") {
+                    landscapeOrientation = (xml.readElementText(QXmlStreamReader::IncludeChildElements) == "1");
+                } else if (xmlName == "upsidedown") {
+                    upsideDown = (xml.readElementText(QXmlStreamReader::IncludeChildElements) == "1");
+                    // sets
+                } else if (xmlName == "set") {
+                    // NOTE: attributes must be read before readElementText()
+                    QXmlStreamAttributes attrs = xml.attributes();
+                    QString setName = xml.readElementText(QXmlStreamReader::IncludeChildElements);
+                    PrintingInfo setInfo(internalAddSet(setName));
+                    if (attrs.hasAttribute("muId")) {
+                        setInfo.setProperty("muid", attrs.value("muId").toString());
+                    }
+
+                    if (attrs.hasAttribute("muId")) {
+                        setInfo.setProperty("uuid", attrs.value("uuId").toString());
+                    }
+
+                    if (attrs.hasAttribute("picURL")) {
+                        setInfo.setProperty("picurl", attrs.value("picURL").toString());
+                    }
+
+                    if (attrs.hasAttribute("num")) {
+                        setInfo.setProperty("num", attrs.value("num").toString());
+                    }
+
+                    if (attrs.hasAttribute("rarity")) {
+                        setInfo.setProperty("rarity", attrs.value("rarity").toString());
+                    }
+                    _sets[setName].append(setInfo);
+                    // related cards
+                } else if (xmlName == "related" || xmlName == "reverse-related") {
+                    CardRelation::AttachType attach = CardRelation::DoesNotAttach;
+                    bool exclude = false;
+                    bool variable = false;
+                    int count = 1;
+                    QXmlStreamAttributes attrs = xml.attributes();
+                    QString cardName = xml.readElementText(QXmlStreamReader::IncludeChildElements);
+                    if (attrs.hasAttribute("count")) {
+                        if (attrs.value("count").toString().indexOf("x=") == 0) {
+                            variable = true;
+                            count = attrs.value("count").toString().remove(0, 2).toInt();
+                        } else if (attrs.value("count").toString().indexOf("x") == 0) {
+                            variable = true;
+                        } else {
+                            count = attrs.value("count").toString().toInt();
+                        }
+
+                        if (count < 1) {
+                            count = 1;
+                        }
+                    }
+
+                    if (attrs.hasAttribute("attach")) {
+                        attach = CardRelation::AttachTo;
+                    }
+
+                    if (attrs.hasAttribute("exclude")) {
+                        exclude = true;
+                    }
+
+                    auto *relation = new CardRelation(cardName, attach, exclude, variable, count);
+                    if (xmlName == "reverse-related") {
+                        reverseRelatedCards << relation;
+                    } else {
+                        relatedCards << relation;
+                    }
+                } else if (!xmlName.isEmpty()) {
+                    qCInfo(CockatriceXml3Log) << "Unknown card property" << xmlName << ", trying to continue anyway";
+                    xml.skipCurrentElement();
+                }
+            }
+
+            if (name.isEmpty()) {
+                qCWarning(CockatriceXml3Log) << "Encountered card with empty name; skipping";
+                continue;
+            }
+
+            properties.insert("colors", colors);
+            CardInfoPtr newCard =
+                CardInfo::newInstance(name, text, isToken, properties, relatedCards, reverseRelatedCards, _sets, cipt,
+                                      landscapeOrientation, tableRow, upsideDown);
+            emit addCard(newCard);
+        }
+    }
+}
+
+static QXmlStreamWriter &operator<<(QXmlStreamWriter &xml, const CardSetPtr &set)
+{
+    if (set.isNull()) {
+        qCWarning(CockatriceXml3Log) << "&operator<< set is nullptr";
+        return xml;
+    }
+
+    xml.writeStartElement("set");
+    xml.writeTextElement("name", set->getShortName());
+    xml.writeTextElement("longname", set->getLongName());
+    xml.writeTextElement("settype", set->getSetType());
+    xml.writeTextElement("releasedate", set->getReleaseDate().toString(Qt::ISODate));
+    xml.writeEndElement();
+
+    return xml;
+}
+
+static QXmlStreamWriter &operator<<(QXmlStreamWriter &xml, const CardInfoPtr &info)
+{
+    if (info.isNull()) {
+        qCWarning(CockatriceXml3Log) << "operator<< info is nullptr";
+        return xml;
+    }
+
+    QString tmpString;
+
+    xml.writeStartElement("card");
+
+    // variable - assigned properties
+    xml.writeTextElement("name", info->getName());
+    xml.writeTextElement("text", info->getText());
+    if (info->getIsToken()) {
+        xml.writeTextElement("token", "1");
+    }
+
+    // generic properties
+    xml.writeTextElement("manacost", info->getProperty("manacost"));
+    xml.writeTextElement("cmc", info->getProperty("cmc"));
+    xml.writeTextElement("type", info->getProperty("type"));
+
+    int colorSize = info->getColors().size();
+    for (int i = 0; i < colorSize; ++i) {
+        xml.writeTextElement("color", info->getColors().at(i));
+    }
+
+    tmpString = info->getProperty("pt");
+    if (!tmpString.isEmpty()) {
+        xml.writeTextElement("pt", tmpString);
+    }
+
+    tmpString = info->getProperty("loyalty");
+    if (!tmpString.isEmpty()) {
+        xml.writeTextElement("loyalty", tmpString);
+    }
+
+    // sets
+    const SetToPrintingsMap setMap = info->getSets();
+    for (const auto &printings : setMap) {
+        for (const PrintingInfo &set : printings) {
+            xml.writeStartElement("set");
+            xml.writeAttribute("rarity", set.getProperty("rarity"));
+            xml.writeAttribute("muId", set.getProperty("muid"));
+            xml.writeAttribute("uuId", set.getProperty("uuid"));
+
+            tmpString = set.getProperty("num");
+            if (!tmpString.isEmpty()) {
+                xml.writeAttribute("num", tmpString);
+            }
+
+            tmpString = set.getProperty("picurl");
+            if (!tmpString.isEmpty()) {
+                xml.writeAttribute("picURL", tmpString);
+            }
+
+            xml.writeCharacters(set.getSet()->getShortName());
+            xml.writeEndElement();
+        }
+    }
+
+    // related cards
+    const QList<CardRelation *> related = info->getRelatedCards();
+    for (auto i : related) {
+        xml.writeStartElement("related");
+        if (i->getDoesAttach()) {
+            xml.writeAttribute("attach", "attach");
+        }
+        if (i->getIsCreateAllExclusion()) {
+            xml.writeAttribute("exclude", "exclude");
+        }
+
+        if (i->getIsVariable()) {
+            if (1 == i->getDefaultCount()) {
+                xml.writeAttribute("count", "x");
+            } else {
+                xml.writeAttribute("count", "x=" + QString::number(i->getDefaultCount()));
+            }
+        } else if (1 != i->getDefaultCount()) {
+            xml.writeAttribute("count", QString::number(i->getDefaultCount()));
+        }
+        xml.writeCharacters(i->getName());
+        xml.writeEndElement();
+    }
+    const QList<CardRelation *> reverseRelated = info->getReverseRelatedCards();
+    for (auto i : reverseRelated) {
+        xml.writeStartElement("reverse-related");
+        if (i->getDoesAttach()) {
+            xml.writeAttribute("attach", "attach");
+        }
+
+        if (i->getIsCreateAllExclusion()) {
+            xml.writeAttribute("exclude", "exclude");
+        }
+
+        if (i->getIsVariable()) {
+            if (1 == i->getDefaultCount()) {
+                xml.writeAttribute("count", "x");
+            } else {
+                xml.writeAttribute("count", "x=" + QString::number(i->getDefaultCount()));
+            }
+        } else if (1 != i->getDefaultCount()) {
+            xml.writeAttribute("count", QString::number(i->getDefaultCount()));
+        }
+        xml.writeCharacters(i->getName());
+        xml.writeEndElement();
+    }
+
+    // positioning
+    xml.writeTextElement("tablerow", QString::number(info->getTableRow()));
+    if (info->getCipt()) {
+        xml.writeTextElement("cipt", "1");
+    }
+    if (info->getLandscapeOrientation()) {
+        xml.writeTextElement("landscapeOrientation", "1");
+    }
+    if (info->getUpsideDownArt()) {
+        xml.writeTextElement("upsidedown", "1");
+    }
+
+    xml.writeEndElement(); // card
+
+    return xml;
+}
+
+bool CockatriceXml3Parser::saveToFile(SetNameMap _sets,
+                                      CardNameMap cards,
+                                      const QString &fileName,
+                                      const QString &sourceUrl,
+                                      const QString &sourceVersion)
+{
+    QFile file(fileName);
+    if (!file.open(QIODevice::WriteOnly)) {
+        return false;
+    }
+
+    QXmlStreamWriter xml(&file);
+
+    xml.setAutoFormatting(true);
+    xml.writeStartDocument();
+    xml.writeStartElement(COCKATRICE_XML3_TAGNAME);
+    xml.writeAttribute("version", QString::number(COCKATRICE_XML3_TAGVER));
+    xml.writeAttribute("xmlns:xsi", COCKATRICE_XML_XSI_NAMESPACE);
+    xml.writeAttribute("xsi:schemaLocation", COCKATRICE_XML3_SCHEMALOCATION);
+
+    xml.writeStartElement("info");
+    xml.writeTextElement("author", QCoreApplication::applicationName() + QString(" %1").arg(VERSION_STRING));
+    xml.writeTextElement("createdAt", QDateTime::currentDateTimeUtc().toString(Qt::ISODate));
+    xml.writeTextElement("sourceUrl", sourceUrl);
+    xml.writeTextElement("sourceVersion", sourceVersion);
+    xml.writeEndElement();
+
+    if (_sets.count() > 0) {
+        xml.writeStartElement("sets");
+        for (CardSetPtr set : _sets) {
+            xml << set;
+        }
+        xml.writeEndElement();
+    }
+
+    if (cards.count() > 0) {
+        xml.writeStartElement("cards");
+        for (CardInfoPtr card : cards) {
+            xml << card;
+        }
+        xml.writeEndElement();
+    }
+
+    xml.writeEndElement(); // cockatrice_carddatabase
+    xml.writeEndDocument();
+
+    return true;
+}

cockatrice/src/database/parser/cockatrice_xml_3.h

@@ -0,0 +1,32 @@
+#ifndef COCKATRICE_XML3_H
+#define COCKATRICE_XML3_H
+
+#include "card_database_parser.h"
+
+#include <QLoggingCategory>
+#include <QXmlStreamReader>
+
+inline Q_LOGGING_CATEGORY(CockatriceXml3Log, "cockatrice_xml.xml_3_parser");
+
+class CockatriceXml3Parser : public ICardDatabaseParser
+{
+    Q_OBJECT
+    Q_INTERFACES(ICardDatabaseParser)
+public:
+    CockatriceXml3Parser() = default;
+    ~CockatriceXml3Parser() override = default;
+    bool getCanParseFile(const QString &name, QIODevice &device) override;
+    void parseFile(QIODevice &device) override;
+    bool saveToFile(SetNameMap _sets,
+                    CardNameMap cards,
+                    const QString &fileName,
+                    const QString &sourceUrl = "unknown",
+                    const QString &sourceVersion = "unknown") override;
+
+private:
+    void loadCardsFromXml(QXmlStreamReader &xml);
+    void loadSetsFromXml(QXmlStreamReader &xml);
+    QString getMainCardType(QString &type);
+};
+
+#endif

cockatrice/src/database/parser/cockatrice_xml_4.cpp

@@ -0,0 +1,440 @@
+#include "cockatrice_xml_4.h"
+
+#include "../../settings/cache_settings.h"
+
+#include <QCoreApplication>
+#include <QDebug>
+#include <QFile>
+#include <QXmlStreamReader>
+#include <version_string.h>
+
+#define COCKATRICE_XML4_TAGNAME "cockatrice_carddatabase"
+#define COCKATRICE_XML4_TAGVER 4
+#define COCKATRICE_XML4_SCHEMALOCATION                                                                                 \
+    "https://raw.githubusercontent.com/Cockatrice/Cockatrice/master/doc/carddatabase_v4/cards.xsd"
+
+bool CockatriceXml4Parser::getCanParseFile(const QString &fileName, QIODevice &device)
+{
+    qCInfo(CockatriceXml4Log) << "Trying to parse: " << fileName;
+
+    if (!fileName.endsWith(".xml", Qt::CaseInsensitive)) {
+        qCInfo(CockatriceXml4Log) << "Parsing failed: wrong extension";
+        return false;
+    }
+
+    QXmlStreamReader xml(&device);
+    while (!xml.atEnd()) {
+        if (xml.readNext() == QXmlStreamReader::StartElement) {
+            if (xml.name().toString() == COCKATRICE_XML4_TAGNAME) {
+                int version = xml.attributes().value("version").toString().toInt();
+                if (version == COCKATRICE_XML4_TAGVER) {
+                    return true;
+                } else {
+                    qCInfo(CockatriceXml4Log) << "Parsing failed: wrong version" << version;
+                    return false;
+                }
+
+            } else {
+                qCInfo(CockatriceXml4Log) << "Parsing failed: wrong element tag" << xml.name();
+                return false;
+            }
+        }
+    }
+
+    return true;
+}
+
+void CockatriceXml4Parser::parseFile(QIODevice &device)
+{
+    QXmlStreamReader xml(&device);
+    while (!xml.atEnd()) {
+        if (xml.readNext() == QXmlStreamReader::StartElement) {
+            while (!xml.atEnd()) {
+                if (xml.readNext() == QXmlStreamReader::EndElement) {
+                    break;
+                }
+
+                auto xmlName = xml.name().toString();
+                if (xmlName == "sets") {
+                    loadSetsFromXml(xml);
+                } else if (xmlName == "cards") {
+                    loadCardsFromXml(xml);
+                } else if (!xmlName.isEmpty()) {
+                    qCInfo(CockatriceXml4Log) << "Unknown item" << xmlName << ", trying to continue anyway";
+                    xml.skipCurrentElement();
+                }
+            }
+        }
+    }
+
+    if (xml.hasError()) {
+        QString preamble = tr("Parse error at line %1 col %2:").arg(xml.lineNumber()).arg(xml.columnNumber());
+        qCWarning(CockatriceXml4Log).noquote() << preamble << xml.errorString();
+    }
+}
+
+void CockatriceXml4Parser::loadSetsFromXml(QXmlStreamReader &xml)
+{
+    while (!xml.atEnd()) {
+        if (xml.readNext() == QXmlStreamReader::EndElement) {
+            break;
+        }
+
+        auto xmlName = xml.name().toString();
+        if (xmlName == "set") {
+            QString shortName, longName, setType;
+            QDate releaseDate;
+            short priority;
+            while (!xml.atEnd()) {
+                if (xml.readNext() == QXmlStreamReader::EndElement) {
+                    break;
+                }
+                xmlName = xml.name().toString();
+
+                if (xmlName == "name") {
+                    shortName = xml.readElementText(QXmlStreamReader::IncludeChildElements);
+                } else if (xmlName == "longname") {
+                    longName = xml.readElementText(QXmlStreamReader::IncludeChildElements);
+                } else if (xmlName == "settype") {
+                    setType = xml.readElementText(QXmlStreamReader::IncludeChildElements);
+                } else if (xmlName == "releasedate") {
+                    releaseDate =
+                        QDate::fromString(xml.readElementText(QXmlStreamReader::IncludeChildElements), Qt::ISODate);
+                } else if (xmlName == "priority") {
+                    priority = xml.readElementText(QXmlStreamReader::IncludeChildElements).toShort();
+                } else if (!xmlName.isEmpty()) {
+                    qCInfo(CockatriceXml4Log) << "Unknown set property" << xmlName << ", trying to continue anyway";
+                    xml.skipCurrentElement();
+                }
+            }
+
+            internalAddSet(shortName, longName, setType, releaseDate, static_cast<CardSet::Priority>(priority));
+        }
+    }
+}
+
+QVariantHash CockatriceXml4Parser::loadCardPropertiesFromXml(QXmlStreamReader &xml)
+{
+    QVariantHash properties = QVariantHash();
+    while (!xml.atEnd()) {
+        if (xml.readNext() == QXmlStreamReader::EndElement) {
+            break;
+        }
+
+        auto xmlName = xml.name().toString();
+        if (!xmlName.isEmpty()) {
+            properties.insert(xmlName, xml.readElementText(QXmlStreamReader::IncludeChildElements));
+        }
+    }
+    return properties;
+}
+
+void CockatriceXml4Parser::loadCardsFromXml(QXmlStreamReader &xml)
+{
+    bool includeRebalancedCards = SettingsCache::instance().getIncludeRebalancedCards();
+    while (!xml.atEnd()) {
+        if (xml.readNext() == QXmlStreamReader::EndElement) {
+            break;
+        }
+
+        auto xmlName = xml.name().toString();
+
+        if (xmlName == "card") {
+            QString name = QString("");
+            QString text = QString("");
+            QVariantHash properties = QVariantHash();
+            QList<CardRelation *> relatedCards, reverseRelatedCards;
+            auto _sets = SetToPrintingsMap();
+            int tableRow = 0;
+            bool cipt = false;
+            bool landscapeOrientation = false;
+            bool isToken = false;
+            bool upsideDown = false;
+
+            while (!xml.atEnd()) {
+                if (xml.readNext() == QXmlStreamReader::EndElement) {
+                    break;
+                }
+
+                xmlName = xml.name().toString();
+
+                // variable - assigned properties
+                if (xmlName == "name") {
+                    name = xml.readElementText(QXmlStreamReader::IncludeChildElements);
+                } else if (xmlName == "text") {
+                    text = xml.readElementText(QXmlStreamReader::IncludeChildElements);
+                } else if (xmlName == "token") {
+                    isToken = static_cast<bool>(xml.readElementText(QXmlStreamReader::IncludeChildElements).toInt());
+                    // generic properties
+                } else if (xmlName == "prop") {
+                    properties = loadCardPropertiesFromXml(xml);
+                    // positioning info
+                } else if (xmlName == "tablerow") {
+                    tableRow = xml.readElementText(QXmlStreamReader::IncludeChildElements).toInt();
+                } else if (xmlName == "cipt") {
+                    cipt = (xml.readElementText(QXmlStreamReader::IncludeChildElements) == "1");
+                } else if (xmlName == "landscapeOrientation") {
+                    landscapeOrientation = (xml.readElementText(QXmlStreamReader::IncludeChildElements) == "1");
+                } else if (xmlName == "upsidedown") {
+                    upsideDown = (xml.readElementText(QXmlStreamReader::IncludeChildElements) == "1");
+                    // sets
+                } else if (xmlName == "set") {
+                    // NOTE: attributes but be read before readElementText()
+                    QXmlStreamAttributes attrs = xml.attributes();
+                    QString setName = xml.readElementText(QXmlStreamReader::IncludeChildElements);
+                    auto set = internalAddSet(setName);
+                    if (set->getEnabled()) {
+                        PrintingInfo printingInfo(set);
+                        for (QXmlStreamAttribute attr : attrs) {
+                            QString attrName = attr.name().toString();
+                            if (attrName == "picURL")
+                                attrName = "picurl";
+                            printingInfo.setProperty(attrName, attr.value().toString());
+                        }
+
+                        // This is very much a hack and not the right place to
+                        // put this check, as it requires a reload of Cockatrice
+                        // to be apply.
+                        //
+                        // However, this is also true of the `set->getEnabled()`
+                        // check above (which is currently bugged as well), so
+                        // we'll fix both at the same time.
+                        if (includeRebalancedCards || printingInfo.getProperty("isRebalanced") != "true") {
+                            _sets[setName].append(printingInfo);
+                        }
+                    }
+                    // related cards
+                } else if (xmlName == "related" || xmlName == "reverse-related") {
+                    CardRelation::AttachType attachType = CardRelation::DoesNotAttach;
+                    bool exclude = false;
+                    bool variable = false;
+                    bool persistent = false;
+                    int count = 1;
+                    QXmlStreamAttributes attrs = xml.attributes();
+                    QString cardName = xml.readElementText(QXmlStreamReader::IncludeChildElements);
+                    if (attrs.hasAttribute("count")) {
+                        if (attrs.value("count").toString().indexOf("x=") == 0) {
+                            variable = true;
+                            count = attrs.value("count").toString().remove(0, 2).toInt();
+                        } else if (attrs.value("count").toString().indexOf("x") == 0) {
+                            variable = true;
+                        } else {
+                            count = attrs.value("count").toString().toInt();
+                        }
+
+                        if (count < 1) {
+                            count = 1;
+                        }
+                    }
+
+                    if (attrs.hasAttribute("attach")) {
+                        attachType = attrs.value("attach").toString() == "transform" ? CardRelation::TransformInto
+                                                                                     : CardRelation::AttachTo;
+                    }
+
+                    if (attrs.hasAttribute("exclude")) {
+                        exclude = true;
+                    }
+
+                    if (attrs.hasAttribute("persistent")) {
+                        persistent = true;
+                    }
+
+                    auto *relation = new CardRelation(cardName, attachType, exclude, variable, count, persistent);
+                    if (xmlName == "reverse-related") {
+                        reverseRelatedCards << relation;
+                    } else {
+                        relatedCards << relation;
+                    }
+                } else if (!xmlName.isEmpty()) {
+                    qCInfo(CockatriceXml4Log) << "Unknown card property" << xmlName << ", trying to continue anyway";
+                    xml.skipCurrentElement();
+                }
+            }
+
+            if (name.isEmpty()) {
+                qCWarning(CockatriceXml4Log) << "Encountered card with empty name; skipping";
+                continue;
+            }
+
+            CardInfoPtr newCard =
+                CardInfo::newInstance(name, text, isToken, properties, relatedCards, reverseRelatedCards, _sets, cipt,
+                                      landscapeOrientation, tableRow, upsideDown);
+            emit addCard(newCard);
+        }
+    }
+}
+
+static QXmlStreamWriter &operator<<(QXmlStreamWriter &xml, const CardSetPtr &set)
+{
+    if (set.isNull()) {
+        qCWarning(CockatriceXml4Log) << "&operator<< set is nullptr";
+        return xml;
+    }
+
+    xml.writeStartElement("set");
+    xml.writeTextElement("name", set->getShortName());
+    xml.writeTextElement("longname", set->getLongName());
+    xml.writeTextElement("settype", set->getSetType());
+    xml.writeTextElement("releasedate", set->getReleaseDate().toString(Qt::ISODate));
+    xml.writeTextElement("priority", QString::number(set->getPriority()));
+    xml.writeEndElement();
+
+    return xml;
+}
+
+static QXmlStreamWriter &operator<<(QXmlStreamWriter &xml, const CardInfoPtr &info)
+{
+    if (info.isNull()) {
+        qCWarning(CockatriceXml4Log) << "operator<< info is nullptr";
+        return xml;
+    }
+
+    QString tmpString;
+
+    xml.writeStartElement("card");
+
+    // variable - assigned properties
+    xml.writeTextElement("name", info->getName());
+    xml.writeTextElement("text", info->getText());
+    if (info->getIsToken()) {
+        xml.writeTextElement("token", "1");
+    }
+
+    // generic properties
+    xml.writeStartElement("prop");
+    for (QString propName : info->getProperties()) {
+        xml.writeTextElement(propName, info->getProperty(propName));
+    }
+    xml.writeEndElement();
+
+    // sets
+    for (const auto &printings : info->getSets()) {
+        for (const PrintingInfo &set : printings) {
+            xml.writeStartElement("set");
+            for (const QString &propName : set.getProperties()) {
+                xml.writeAttribute(propName, set.getProperty(propName));
+            }
+
+            xml.writeCharacters(set.getSet()->getShortName());
+            xml.writeEndElement();
+        }
+    }
+
+    // related cards
+    const QList<CardRelation *> related = info->getRelatedCards();
+    for (auto i : related) {
+        xml.writeStartElement("related");
+        if (i->getDoesAttach()) {
+            xml.writeAttribute("attach", i->getAttachTypeAsString());
+        }
+        if (i->getIsCreateAllExclusion()) {
+            xml.writeAttribute("exclude", "exclude");
+        }
+        if (i->getIsPersistent()) {
+            xml.writeAttribute("persistent", "persistent");
+        }
+        if (i->getIsVariable()) {
+            if (1 == i->getDefaultCount()) {
+                xml.writeAttribute("count", "x");
+            } else {
+                xml.writeAttribute("count", "x=" + QString::number(i->getDefaultCount()));
+            }
+        } else if (1 != i->getDefaultCount()) {
+            xml.writeAttribute("count", QString::number(i->getDefaultCount()));
+        }
+        xml.writeCharacters(i->getName());
+        xml.writeEndElement();
+    }
+    const QList<CardRelation *> reverseRelated = info->getReverseRelatedCards();
+    for (auto i : reverseRelated) {
+        xml.writeStartElement("reverse-related");
+        if (i->getDoesAttach()) {
+            xml.writeAttribute("attach", i->getAttachTypeAsString());
+        }
+
+        if (i->getIsCreateAllExclusion()) {
+            xml.writeAttribute("exclude", "exclude");
+        }
+
+        if (i->getIsPersistent()) {
+            xml.writeAttribute("persistent", "persistent");
+        }
+        if (i->getIsVariable()) {
+            if (1 == i->getDefaultCount()) {
+                xml.writeAttribute("count", "x");
+            } else {
+                xml.writeAttribute("count", "x=" + QString::number(i->getDefaultCount()));
+            }
+        } else if (1 != i->getDefaultCount()) {
+            xml.writeAttribute("count", QString::number(i->getDefaultCount()));
+        }
+        xml.writeCharacters(i->getName());
+        xml.writeEndElement();
+    }
+
+    // positioning
+    xml.writeTextElement("tablerow", QString::number(info->getTableRow()));
+    if (info->getCipt()) {
+        xml.writeTextElement("cipt", "1");
+    }
+    if (info->getLandscapeOrientation()) {
+        xml.writeTextElement("landscapeOrientation", "1");
+    }
+    if (info->getUpsideDownArt()) {
+        xml.writeTextElement("upsidedown", "1");
+    }
+
+    xml.writeEndElement(); // card
+
+    return xml;
+}
+
+bool CockatriceXml4Parser::saveToFile(SetNameMap _sets,
+                                      CardNameMap cards,
+                                      const QString &fileName,
+                                      const QString &sourceUrl,
+                                      const QString &sourceVersion)
+{
+    QFile file(fileName);
+    if (!file.open(QIODevice::WriteOnly)) {
+        return false;
+    }
+
+    QXmlStreamWriter xml(&file);
+
+    xml.setAutoFormatting(true);
+    xml.writeStartDocument();
+    xml.writeStartElement(COCKATRICE_XML4_TAGNAME);
+    xml.writeAttribute("version", QString::number(COCKATRICE_XML4_TAGVER));
+    xml.writeAttribute("xmlns:xsi", COCKATRICE_XML_XSI_NAMESPACE);
+    xml.writeAttribute("xsi:schemaLocation", COCKATRICE_XML4_SCHEMALOCATION);
+
+    xml.writeStartElement("info");
+    xml.writeTextElement("author", QCoreApplication::applicationName() + QString(" %1").arg(VERSION_STRING));
+    xml.writeTextElement("createdAt", QDateTime::currentDateTimeUtc().toString(Qt::ISODate));
+    xml.writeTextElement("sourceUrl", sourceUrl);
+    xml.writeTextElement("sourceVersion", sourceVersion);
+    xml.writeEndElement();
+
+    if (_sets.count() > 0) {
+        xml.writeStartElement("sets");
+        for (CardSetPtr set : _sets) {
+            xml << set;
+        }
+        xml.writeEndElement();
+    }
+
+    if (cards.count() > 0) {
+        xml.writeStartElement("cards");
+        for (CardInfoPtr card : cards) {
+            xml << card;
+        }
+        xml.writeEndElement();
+    }
+
+    xml.writeEndElement(); // cockatrice_carddatabase
+    xml.writeEndDocument();
+
+    return true;
+}

cockatrice/src/database/parser/cockatrice_xml_4.h

@@ -0,0 +1,32 @@
+#ifndef COCKATRICE_XML4_H
+#define COCKATRICE_XML4_H
+
+#include "card_database_parser.h"
+
+#include <QLoggingCategory>
+#include <QXmlStreamReader>
+
+inline Q_LOGGING_CATEGORY(CockatriceXml4Log, "cockatrice_xml.xml_4_parser");
+
+class CockatriceXml4Parser : public ICardDatabaseParser
+{
+    Q_OBJECT
+    Q_INTERFACES(ICardDatabaseParser)
+public:
+    CockatriceXml4Parser() = default;
+    ~CockatriceXml4Parser() override = default;
+    bool getCanParseFile(const QString &name, QIODevice &device) override;
+    void parseFile(QIODevice &device) override;
+    bool saveToFile(SetNameMap _sets,
+                    CardNameMap cards,
+                    const QString &fileName,
+                    const QString &sourceUrl = "unknown",
+                    const QString &sourceVersion = "unknown") override;
+
+private:
+    QVariantHash loadCardPropertiesFromXml(QXmlStreamReader &xml);
+    void loadCardsFromXml(QXmlStreamReader &xml);
+    void loadSetsFromXml(QXmlStreamReader &xml);
+};
+
+#endif