Add support for individual pack versions per scenario

1 files changed, 167 insertions, 2 deletions

diff --git a/src/CRSMPackCompatibility.cpp b/src/CRSMPackCompatibility.cpp
index 481cf44..cea57f7 100644
--- a/src/CRSMPackCompatibility.cpp
+++ b/src/CRSMPackCompatibility.cpp
@@ -1,7 +1,172 @@
-#include "PackCompatibility.hpp"
+#include "CRSMPackCompatibility.hpp"
 
-PackCompatibility::PackCompatibility()
+#include <QFile>
+
+void CRSMPackCompatibility::clear()
 {
+    auto configVals = configValues;
+    *this = CRSMPackCompatibility();
+    configValues = configVals;
+}
+
+QString CRSMPackCompatibility::linkScenarioPacks(const QString &scenario)
+{
+    QStringList parts;
+    parts.append(scenario);
+    QString ret;
+    int position = scenario.length();
+    while((position = scenario.lastIndexOf('/', position - 1)) != -1)
+    {
+        parts.append(scenario.left(position));
+    }
+
+    QMap<QString, QString> packs = PackDefaultVersion;
+    foreach(const QString& filePathPart, parts)
+    {
+        foreach(const QString& packVersion, ScenarioPacks.value(filePathPart))
+        {
+            packs[PackVersions[packVersion]] = packVersion;
+        }
+    }
 
+    foreach(const QString& packName, packs.keys())
+    {
+        QFile packFile(clonkPath + packName);
+        if(packFile.exists())
+        {
+            packFile.remove();
+        }
+        if(!QFile::link(clonkPath + packs[packName], clonkPath + packName))
+        {
+            ret.append("Warning: Could not link pack \"" + packName + "\" to \"" + packs[packName] + "\".\n");
+        }
+    }
+
+    return ret;
 }
 
+QString CRSMPackCompatibility::read(const QString &fileName, const QString& clonkPath, bool writeDefault)
+{
+    this->clonkPath = clonkPath;
+    QString ret = ConfigBase::read(fileName, writeDefault);
+
+    foreach(const QString& packVersion, PackVersions.keys())
+    {
+        ret.append(checkPackVersion(packVersion, PackVersions[packVersion]));
+    }
+
+    foreach(const QString& scenario, ScenarioPacks.keys())
+    {
+        foreach(const QString& scenarioPack, ScenarioPacks[scenario])
+        {
+            ret.append(checkScenarioPack(scenarioPack, scenario));
+        }
+    }
+
+    return ret;
+}
+
+QString CRSMPackCompatibility::addPackVersion(const QString &packVersion, const QString &pack)
+{
+    PackVersions[packVersion] = pack;
+    if(!PackDefaultVersion.contains(pack))
+    {
+        PackDefaultVersion[pack] = packVersion;
+    }
+    return checkPackVersion(packVersion, pack);
+}
+
+QString CRSMPackCompatibility::deletePackVersion(const QString &packVersion)
+{
+    if(PackVersions.contains(packVersion))
+    {
+        const QString& pack = PackVersions.value(packVersion);
+        PackVersions.remove(packVersion);
+        if(PackVersions.values().count(pack) == 0)
+        {
+            PackDefaultVersion.remove(pack);
+        }
+        else if(PackDefaultVersion.value(pack) == packVersion)
+        {
+            PackDefaultVersion[pack] = PackVersions.key(pack);
+            return "Warning: Changing default version of \"" + pack + "\" to \"" + PackDefaultVersion[pack] + "\".\n";
+        }
+        return "";
+    }
+    else
+    {
+        return "Error: Can not remove unknown PackVersion.";
+    }
+}
+
+QString CRSMPackCompatibility::setDefaultPackVersion(const QString &packVersion, const QString &pack)
+{
+    PackDefaultVersion[pack] = packVersion;
+    QString ret = addPackVersion(packVersion, pack);
+    return ret;
+}
+
+QString CRSMPackCompatibility::addScenarioPackVersion(const QString &packVersion, const QString &scenario)
+{
+    QString ret = checkScenarioPack(packVersion, scenario);
+    if(ret.isEmpty())
+    {
+        QString pack = PackVersions.value(packVersion);
+        foreach(const QString& scenarioPack, ScenarioPacks[scenario])
+        {
+            if(pack == PackVersions.value(scenarioPack))
+            {
+                ScenarioPacks[scenario].removeAll(scenarioPack);
+                ret = "Overwriting old PackVersion \"" + scenarioPack + "\" with \"" + packVersion + "\".\n";
+            }
+        }
+    }
+
+    ScenarioPacks[scenario].append(packVersion);
+    return ret;
+}
+
+QString CRSMPackCompatibility::deleteScenarioPackVersion(const QString &packVersion, const QString &scenario)
+{
+    if(!ScenarioPacks.contains(scenario))
+    {
+        return "Warning: The scenario \"" + scenario + "\" has no ScenarioPacks defined.\n";
+    }
+    else if(!ScenarioPacks[scenario].contains(packVersion))
+    {
+        return "Warning: The scenario \"" + scenario + "\" has no ScenarioPack \"" + packVersion + "\" defined.\n";
+    }
+    else
+    {
+        ScenarioPacks[scenario].removeAll(packVersion);
+        if(ScenarioPacks[scenario].length() == 0)
+        {
+            ScenarioPacks.remove(scenario);
+        }
+        return "";
+    }
+}
+
+QString CRSMPackCompatibility::checkPackVersion(const QString &packVersion, const QString &pack)
+{
+    if(!QFile(clonkPath + packVersion).exists())
+    {
+        return "Warning: PackVersion \"" + packVersion + "\" of pack \"" + pack + "\" does not exist.\n";
+    }
+    else
+    {
+        return "";
+    }
+}
+
+QString CRSMPackCompatibility::checkScenarioPack(const QString &packVersion, const QString &scenario)
+{
+    if(!PackVersions.contains(packVersion))
+    {
+        return "Warning: Unknown ScenarioPack \"" + packVersion + "\" of scenario \"" + scenario + "\" will not be linked.\n";
+    }
+    else
+    {
+        return "";
+    }
+}