Fix all runners (#3)

* fix all runners - start

* use 4 worker threads

* run on the other thread and print the output

bash work

* Add back UMU and wine, better separation of concerns

* dont clear systemEnvironment

* fix just link

* fix lutris and steam

Author: noisecode3

CMakeLists.txt

@@ -46,6 +46,7 @@ if(NOT EXISTS "${CMAKE_SOURCE_DIR}/libs/LIEF/CMakeLists.txt")
     )
 endif()
 set(LIEF_INSTALL OFF CACHE BOOL "Disable installation of LIEF")
+set(LIEF_PYTHON_API OFF)
 set(LIEF_EXAMPLES OFF)
 set(LIEF_TESTS OFF)
 set(LIEF_DOC OFF)
@@ -137,6 +138,7 @@ set(SOURCES_MC
     src/binary.hpp
     src/binary.cpp
     src/gameFileTreeData.hpp
+    src/globalTypes.hpp
     src/main.cpp
     src/staticData.hpp
 )

libs/LIEF

@@ -15,16 +15,25 @@
 #include <QMetaObject>
 
 Controller::Controller() {
-    threadA.reset(new QThread());
-    threadB.reset(new QThread());
-    workerA.reset(new QObject());
-    workerB.reset(new QObject());
-
-    workerA->moveToThread(threadA.data());
-    workerB->moveToThread(threadB.data());
-
-    threadA->start();
-    threadB->start();
+    threadDatabase.reset(new QThread());
+    threadFile.reset(new QThread());
+    threadScrape.reset(new QThread());
+    threadRun.reset(new QThread());
+
+    workerDatabase.reset(new QObject());
+    workerFile.reset(new QObject());
+    workerScrape.reset(new QObject());
+    workerRun.reset(new QObject());
+
+    workerDatabase->moveToThread(threadDatabase.data());
+    workerFile->moveToThread(threadFile.data());
+    workerScrape->moveToThread(threadScrape.data());
+    workerRun->moveToThread(threadRun.data());
+
+    threadDatabase->start();
+    threadFile->start();
+    threadScrape->start();
+    threadRun->start();
 
     connect(&model, &Model::modelTickSignal,
             this,   &Controller::controllerTickSignal,
@@ -53,48 +62,71 @@ Controller::Controller() {
     connect(&model, &Model::modelLoadingDoneSignal,
             this,   &Controller::controllerLoadingDone,
         Qt::QueuedConnection);
+
+    connect(&model, &Model::modelRunningDoneSignal,
+            this,   &Controller::controllerRunningDone,
+        Qt::QueuedConnection);
 }
 
 Controller::~Controller() {
-    threadA->quit();
-    threadB->quit();
-    threadA->wait();
-    threadB->wait();
+    threadDatabase->quit();
+    threadFile->quit();
+    threadScrape->quit();
+    threadRun->quit();
+
+    threadDatabase->wait();
+    threadFile->wait();
+    threadScrape->wait();
+    threadRun->wait();
 }
 
-void Controller::runOnThreadA(std::function<void()> func) {
-    QMetaObject::invokeMethod(
-            workerA.data(), [func]() { func(); }, Qt::QueuedConnection);
+void Controller::runOnThreadDatabase(std::function<void()> func) {
+    QMetaObject::invokeMethod(workerDatabase.data(),
+            [func]() { func(); }, Qt::QueuedConnection);
 }
 
-void Controller::runOnThreadB(std::function<void()> func) {
-    QMetaObject::invokeMethod(
-            workerB.data(), [func]() { func(); }, Qt::QueuedConnection);
+void Controller::runOnThreadFile(std::function<void()> func) {
+    QMetaObject::invokeMethod(workerFile.data(),
+            [func]() { func(); }, Qt::QueuedConnection);
+}
+
+void Controller::runOnThreadScrape(std::function<void()> func) {
+    QMetaObject::invokeMethod(workerScrape.data(),
+            [func]() { func(); }, Qt::QueuedConnection);
+}
+
+void Controller::runOnThreadRun(std::function<void()> func) {
+    QMetaObject::invokeMethod(workerRun.data(),
+            [func]() { func(); }, Qt::QueuedConnection);
 }
 
 // Threaded work
 void Controller::setup() {
-    runOnThreadA([=]() { model.setup(); });
+    runOnThreadFile([=]() { model.setup(); });
 }
 
 void Controller::setupGame(int id) {
-    runOnThreadA([=]() { model.setupGame(id); });
+    runOnThreadFile([=]() { model.setupGame(id); });
 }
 
 void Controller::setupLevel(int id) {
-    runOnThreadA([=]() { model.getLevel(id); });
+    runOnThreadFile([=]() { model.getLevel(id); });
 }
 
 void Controller::updateLevel(int id) {
-    runOnThreadA([=]() { model.updateLevel(id); });
+    runOnThreadScrape([=]() { model.updateLevel(id); });
 }
 
 void Controller::syncLevels() {
-    runOnThreadA([=]() { model.syncLevels(); });
+    runOnThreadScrape([=]() { model.syncLevels(); });
 }
 
 void Controller::getCoverList(QVector<QSharedPointer<ListItemData>> items) {
-    runOnThreadB([=]() { model.getCoverList(items); });
+    runOnThreadDatabase([=]() { model.getCoverList(items); });
+}
+
+void Controller::run(RunnerOptions opptions) {
+    runOnThreadRun([=]() { model.run(opptions); });
 }
 
 // UI/main thread work

src/Controller.cpp

@@ -15,6 +15,7 @@
 #define SRC_CONTROLLER_HPP_
 #include <QObject>
 #include <QThread>
+#include "../src/globalTypes.hpp"
 #include "../src/Model.hpp"
 
 /**
@@ -37,6 +38,7 @@ class Controller : public QObject {
     void updateLevel(int id);
     void syncLevels();
     void getCoverList(QVector<QSharedPointer<ListItemData>> items);
+    void run(RunnerOptions opptions);
 
     int checkGameDirectory(int id);
     void getList(QVector<QSharedPointer<ListItemData>>* list);
@@ -51,19 +53,27 @@ class Controller : public QObject {
     void controllerDownloadError(int status);
     void controllerReloadLevelList();
     void controllerLoadingDone();
+    void controllerRunningDone();
 
  private:
     Controller();
     ~Controller();
     void initThreads();
 
-    void runOnThreadA(std::function<void()> func);
-    void runOnThreadB(std::function<void()> func);
+    void runOnThreadDatabase(std::function<void()> func);
+    void runOnThreadFile(std::function<void()> func);
+    void runOnThreadScrape(std::function<void()> func);
+    void runOnThreadRun(std::function<void()> func);
 
-    QScopedPointer<QThread> threadA;
-    QScopedPointer<QThread> threadB;
-    QScopedPointer<QObject> workerA;
-    QScopedPointer<QObject> workerB;
+    QScopedPointer<QThread> threadDatabase;
+    QScopedPointer<QThread> threadFile;
+    QScopedPointer<QThread> threadScrape;
+    QScopedPointer<QThread> threadRun;
+
+    QScopedPointer<QObject> workerDatabase;
+    QScopedPointer<QObject> workerFile;
+    QScopedPointer<QObject> workerScrape;
+    QScopedPointer<QObject> workerRun;
 
     Data& data = Data::getInstance();
     FileManager& fileManager = FileManager::getInstance();

src/Controller.hpp

@@ -91,6 +91,10 @@ struct SteamAppIds {
             {4, 224980},
             {5, 225000},
             {6, 225020},
+            {7, 224960},
+            {8, 225300},
+            {9, 225320},
+            {10, 224980},
         };
 };
 

src/Data.hpp

@@ -340,3 +340,14 @@ qint64 FileManager::removeFileOrDirectory(Path path) {
     }
     return status;
 }
+
+void FileManager::addLevelDir(Path& path, quint64 id) {
+    // we use original game id as negative number
+
+    if (id < 0) {
+        int orgId = (-1)*id;
+        path << QString("Original.TR%1").arg(orgId);
+    } else {
+        path <<  QString("%1.TRLE").arg(id);
+    }
+}

src/FileManager.cpp

@@ -201,6 +201,8 @@ class FileManager : public QObject {
      */
     qint64 removeFileOrDirectory(Path path);
 
+    void addLevelDir(Path& path, quint64 id);
+
  signals:
     void fileWorkTickSignal();