Add tree level extra path to linking

noisecode3 · noisecode3 · commit 271e6b55fbbe · 2025-01-19T12:25:41.000+01:00
diff --git a/.cppcheck-addons/misra.json b/.cppcheck-addons/misra.json
@@ -1,4 +1,4 @@
 {
   "script": "misra.py",
-  "args": ["--rule-texts=.cppcheck-addons/misra_rules.txt --suppress-rules 8.2,2.7,7.4"]
+  "args": ["--rule-texts=.cppcheck-addons/misra_rules.txt --suppress-rules 8.2,2.7,7.4,15.4"]
 }
diff --git a/src/Data.hpp b/src/Data.hpp
@@ -37,12 +37,15 @@ struct FileList {
  * Except for `TombEngine (TEN)` I made that one up.
  */
 struct FolderNames {
-    const QString TR1 = "/Tomb Raider (I)";
-    const QString TR2 = "/Tomb Raider (II)";
-    const QString TR3 = "/TombRaider (III)";
-    const QString TR4 = "/Tomb Raider (IV) The Last Revelation";
-    const QString TR5 = "/Tomb Raider (V) Chronicles";
-    const QString TEN = "TombEngine (TEN)";
+    QMap<int, QString> data = {
+            {0, "null"},
+            {1, "Tomb Raider (I)"},
+            {2, "Tomb Raider (II)"},
+            {3, "TombRaider (III)"},
+            {4, "Tomb Raider (IV) The Last Revelation"},
+            {5, "Tomb Raider (V) Chronicles"},
+            {6, "TombEngine (TEN)"},
+        };
 };
 
 struct ZipData {
diff --git a/src/FileManager.cpp b/src/FileManager.cpp
@@ -24,6 +24,89 @@
 #include "miniz.h"
 #include "miniz_zip.h"
 
+struct StaticTrees {
+    QList<GameFileTree*> data;
+    StaticTrees() {
+        data.append(new GameFileTree(QStringList{
+            "TOMBRAID/tomb.exe",
+            "dosbox.exe",
+        }));
+        data.append(new GameFileTree(QStringList{
+            "Tomb1Main.exe",
+            "cfg",
+            "data",
+            "shaders",
+        }));
+        data.append(new GameFileTree(QStringList{
+            "TR1X.exe",
+            "cfg",
+            "data",
+            "shaders",
+        }));
+        data.append(new GameFileTree(QStringList{
+            "TR2Main.json",
+            "data",
+        }));
+        data.append(new GameFileTree(QStringList{
+            "Tomb2.exe",
+            "data",
+        }));
+        data.append(new GameFileTree(QStringList{
+            "tomb3_ConfigTool.json",
+            "tomb3.exe",
+            "audio",
+            "data",
+            "pix",
+        }));
+        data.append(new GameFileTree(QStringList{
+            "tomb3.exe",
+            "audio",
+            "data",
+            "Pix",
+        }));
+        data.append(new GameFileTree(QStringList{
+            "tomb3.exe",
+            "audio",
+            "Data",
+        }));
+        data.append(new GameFileTree(QStringList{
+            "tomb3.exe",
+            "audio",
+            "data",
+            "pix",
+        }));
+        data.append(new GameFileTree(QStringList{
+            "tomb4.exe",
+            "audio",
+            "Data",
+        }));
+        data.append(new GameFileTree(QStringList{
+            "tomb4.exe",
+            "audio",
+            "data",
+            "pix",
+        }));
+        data.append(new GameFileTree(QStringList{
+            "audio",
+            "data",
+            "pix",
+        }));
+        data.append(new GameFileTree(QStringList{
+            "PCTomb5.exe",
+            "audio",
+            "data",
+            "pix",
+        }));
+    }
+    ~StaticTrees() {
+        for (GameFileTree* tree : data) {
+            delete tree;
+        }
+        data.clear();
+    }
+};
+
+
 bool FileManager::setUpCamp(const QString& levelDir, const QString& gameDir) {
     bool status = true;
 
@@ -212,21 +295,35 @@ bool FileManager::linkGameDir(const QString& levelDir, const QString& gameDir) {
     bool status = false;
     const QString levelPath = QString("%1%2")
         .arg(m_levelDir.absolutePath(), levelDir);
-    const QString gamePath =  QString("%1%2")
+    const QString gamePath =  QString("%1/%2")
         .arg(m_gameDir.absolutePath(), gameDir);
 
+    StaticTrees staticTrees;
     QDir dir(levelPath);
     GameFileTree test(dir);
     test.printTree(1);
+    QString extraPath;
+
+    for (const GameFileTree* tree : staticTrees.data) {
+        extraPath = test.matchesFromAnyNode(tree);
+        if ((extraPath != QString("\0")) && (!extraPath.isEmpty())) {
+            QTextStream(stdout)
+                << "game tree matches: " << extraPath << Qt::endl;
+            break;
+        }
+    }
+
+    qDebug() << "levelPath: " << levelPath;
+    qDebug() << "gamePath: " << gamePath;
 
-    if (QFile::link(levelPath, gamePath) == true) {
+    if (QFile::link(levelPath + extraPath, gamePath) == true) {
         qDebug() << "Symbolic link created successfully.";
         status = true;
     } else {
         QFileInfo fileInfo(gamePath);
         if (fileInfo.isSymLink() == true) {
             (void)QFile::remove(gamePath);
-            if (QFile::link(levelPath, gamePath) == true) {
+            if (QFile::link(levelPath + extraPath, gamePath) == true) {
                 qDebug() << "Symbolic link created successfully.";
                 status = true;
             } else {
@@ -438,60 +535,3 @@ bool FileManager::moveFilesToDirectory(
     });
 }
 
-bool FileManager::moveFilesToParentDirectory(
-        const QString& levelDirectory, int levelsUp) {
-    const QString& sep = QDir::separator();
-    QDir levelDirectoryFullPath(QString("%1%2%3")
-            .arg(m_levelDir.absolutePath(), sep, levelDirectory));
-
-    if (!levelDirectoryFullPath.exists()) {
-        qWarning() << "Directory does not exist:"
-            << levelDirectoryFullPath.absolutePath();
-        return false;
-    }
-
-    QDir levelDirectoryUpPath = levelDirectoryFullPath;
-
-    for (int i = 0; i < levelsUp; ++i) {
-        if (!levelDirectoryUpPath.cdUp()) {
-            qWarning() << "Failed to access parent directory at level "
-                << i + 1 << " from:" << levelDirectoryFullPath.absolutePath();
-            return false;
-        }
-    }
-
-    QFlags listFlags(QDir::Files | QDir::Dirs | QDir::NoDotAndDotDot);
-    QFileInfoList fileList = levelDirectoryFullPath.entryInfoList(listFlags);
-
-    // Move all files and directories to the parent directory
-    for (const QFileInfo& fileInfo : fileList) {
-        QString srcPath = fileInfo.absoluteFilePath();
-        QString destPath = levelDirectoryUpPath.absolutePath() + sep +
-            fileInfo.fileName();
-
-        if (fileInfo.isDir() == true) {
-            // Move the directory recursively
-            QDir srcDir(srcPath);
-            if (!srcDir.rename(srcPath, destPath)) {
-                qWarning() << "Failed to move directory:" << srcPath;
-                return false;
-            }
-        } else {
-            // Move the file
-            if (!QFile::rename(srcPath, destPath)) {
-                qWarning() << "Failed to move file:" << srcPath;
-                return false;
-            }
-        }
-    }
-
-    QDir parentDir = levelDirectoryFullPath;  // Create a copy
-    parentDir.cdUp();  // Move to the parent directory
-
-    if (!parentDir.rmdir(levelDirectoryFullPath.dirName())) {
-        qWarning() << "Failed to remove directory:"
-            << levelDirectoryFullPath.absolutePath();
-        return false;
-    }
-    return true;
-}
diff --git a/src/FileManager.hpp b/src/FileManager.hpp
@@ -42,7 +42,6 @@ class FileManager : public QObject {
         const QString& fromLevelDirectory,
         const QString& toLevelDirectory);
 
-    bool moveFilesToParentDirectory(const QString& directoryPath, int levelsUp);
     int createDirectory(const QString &file, bool gameDir);
     int copyFile(
         const QString &gameFile,
diff --git a/src/GameFileTree.cpp b/src/GameFileTree.cpp
@@ -42,18 +42,21 @@ GameFileTree::~GameFileTree() {
     }
 }
 
-
-GameFileTree::GameFileTree(const QString& fileList) : m_parentItem(nullptr) {
-    QStringList pathList = fileList.split("\n");
+GameFileTree::GameFileTree(const QStringList& pathList)
+    // cppcheck-suppress misra-c2012-12.3
+    : m_parentItem(nullptr) {
     addPathList(pathList);
 }
 
-GameFileTree::GameFileTree(const QDir &dir) : m_parentItem(nullptr) {
+GameFileTree::GameFileTree(const QDir &dir)
+    // cppcheck-suppress misra-c2012-12.3
+    : m_parentItem(nullptr) {
     if (dir.exists() == true) {
         QStringList pathList;
         // Skapa en kö för att hantera kataloger iterativt
         QQueue<QString> dirQueue;
-        dirQueue.enqueue(dir.absolutePath());
+        const QString base = dir.absolutePath();
+        dirQueue.enqueue(base);
 
         while (!dirQueue.isEmpty()) {
             QString currentDirPath = dirQueue.dequeue();
@@ -68,7 +71,7 @@ GameFileTree::GameFileTree(const QDir &dir) : m_parentItem(nullptr) {
                 QDir::Name);
 
             for (const QFileInfo& fileInfo : fileList) {
-                pathList << fileInfo.absoluteFilePath();
+                pathList << QString(fileInfo.absoluteFilePath().split(base)[1]);
 
                 // Om objektet är en katalog, lägg till den i kön
                 if (fileInfo.isDir() == true) {
@@ -85,15 +88,17 @@ GameFileTree::GameFileTree(const QDir &dir) : m_parentItem(nullptr) {
 
 void GameFileTree::addPathList(const QStringList& pathList) {
     for (const QString& path : pathList) {
-        QStringList components = QDir::toNativeSeparators(path).split(QDir::separator(), Qt::SkipEmptyParts);
+        QStringList components = QDir::toNativeSeparators(path).split(
+            QDir::separator(), Qt::SkipEmptyParts);
         GameFileTree* current = this;
 
         for (const QString& component : components) {
             // Check if a child node with this name already exists
-            auto it = std::find_if(current->m_childItems.begin(), current->m_childItems.end(),
-                                   [&component](GameFileTree* child) {
-                                       return child->m_fileName == component;
-                                   });
+            auto it = std::find_if(
+                current->m_childItems.begin(), current->m_childItems.end(),
+                [&component](GameFileTree* child) {
+                    return child->m_fileName == component;
+            });
 
             if (it == current->m_childItems.end()) {
                 // Node doesn't exist, create it
@@ -116,7 +121,14 @@ void GameFileTree::printTree(int level) const {
 
     while (currentNode != nullptr) {
         if (!currentNode->m_fileName.isEmpty()) {
-            fullPath = currentNode->m_fileName + QDir::separator() + fullPath;
+            if (fullPath.isEmpty()) {
+                fullPath = currentNode->m_fileName;
+            } else {
+                fullPath = QString("%1%2%3")
+                    .arg(currentNode->m_fileName)
+                    .arg(QDir::separator())
+                    .arg(fullPath);
+            }
         }
         currentNode = currentNode->m_parentItem;
     }
@@ -131,3 +143,60 @@ void GameFileTree::printTree(int level) const {
         }
     }
 }
+
+bool GameFileTree::matchesSubtree(const GameFileTree* other) const {
+    if (!other) return false;  // If the other tree is null, no match is possible.
+
+    QQueue<QPair<const GameFileTree*, const GameFileTree*>> queue;
+    queue.enqueue({this, other});  // Start with the root nodes of both trees.
+
+    while (!queue.isEmpty()) {
+        QPair<const GameFileTree*, const GameFileTree*> current = queue.dequeue();
+
+        const GameFileTree* nodeThis = current.first;
+        const GameFileTree* nodeOther = current.second;
+
+        // Check if all children in `nodeOther` match at least one child in `nodeThis`.
+        for (const GameFileTree* childOther : nodeOther->m_childItems) {
+            bool found = false;
+            for (const GameFileTree* childThis : nodeThis->m_childItems) {
+                if (childThis->m_fileName.toUpper() == childOther->m_fileName.toUpper()) {
+                    // Enqueue the matching child nodes for further comparison.
+                    queue.enqueue({childThis, childOther});
+                    found = true;
+                    break;
+                }
+            }
+
+            // If no matching child is found, the subtree does not match.
+            if (!found) {
+                return false;
+            }
+        }
+    }
+
+    return true;  // All nodes and structures matched successfully.
+}
+
+QString GameFileTree::matchesFromAnyNode(const GameFileTree* other) {
+    // If this node matches the subtree, return its name
+    if (matchesSubtree(other)) {
+        return m_fileName;
+    }
+
+    // Otherwise, check children recursively
+    for (GameFileTree* child : m_childItems) {
+        QString childPath = child->matchesFromAnyNode(other);
+        if (!childPath.isEmpty()) {
+            // Build the path backwards
+            return QString("%1%2%3")
+                .arg(m_fileName)
+                .arg(QDir::separator())
+                .arg(childPath);
+        }
+    }
+
+    // No match found
+    return QString("\0");
+}
+
diff --git a/src/GameFileTree.hpp b/src/GameFileTree.hpp
@@ -19,14 +19,17 @@
 #include <QDir>
 #include <QStringList>
 #include <QDebug>
+#include <QList>
 
 class GameFileTree {
  public:
     explicit GameFileTree(const QDir& fullPath);
-    explicit GameFileTree(const QString& fileList);
+    explicit GameFileTree(const QStringList& pathList);
     ~GameFileTree();
 
     void printTree(int level) const;
+    bool matchesSubtree(const GameFileTree* other) const;
+    QString matchesFromAnyNode(const GameFileTree* other);
 
  private:
     explicit GameFileTree(
diff --git a/src/Model.cpp b/src/Model.cpp
diff --git a/src/Network.cpp b/src/Network.cpp
diff --git a/src/Network.hpp b/src/Network.hpp

Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,4 @@`
`1`	`1`	`{`
`2`	`2`	`"script": "misra.py",`
`3`		`- "args": ["--rule-texts=.cppcheck-addons/misra_rules.txt --suppress-rules 8.2,2.7,7.4"]`
	`3`	`+ "args": ["--rule-texts=.cppcheck-addons/misra_rules.txt --suppress-rules 8.2,2.7,7.4,15.4"]`
`4`	`4`	`}`