Merge pull request #15 from ModOrganizer2/plugin_updates

Add diagnoses to Starfield related to plugins

Author: Silarn

src/gamestarfield.cpp

@@ -1,5 +1,7 @@
 #include "gamestarfield.h"
 
+#include "ipluginlist.h"
+
 #include "starfieldbsainvalidation.h"
 #include "starfielddataarchives.h"
 #include "starfieldgameplugins.h"
@@ -16,6 +18,7 @@
 #include <pluginsetting.h>
 
 #include <QCoreApplication>
+#include <QDesktopServices>
 #include <QDir>
 #include <QFileInfo>
 #include <QList>
@@ -26,6 +29,7 @@
 #include <memory>
 
 #include "scopeguard.h"
+#include "utility.h"
 
 using namespace MOBase;
 
@@ -131,7 +135,19 @@ QList<PluginSetting> GameStarfield::settings() const
                           tr("Turn on plugin management. As of Starfield 1.7.33 this "
                              "REQUIRES fixing 'plugins.txt' with a SFSE plugin. This "
                              "will do nothing otherwise."),
-                          false);
+                          false)
+         << PluginSetting(
+                "enable_esp_warning",
+                tr("Show a warning when ESP plugins are enabled in the load order."),
+                true)
+         << PluginSetting(
+                "enable_esl_warning",
+                tr("Show a warning when light plugins are enabled in the load order."),
+                true)
+         << PluginSetting("enable_overlay_warning",
+                          tr("Show a warning when overlay-flagged plugins ar enabled "
+                             "in the load order."),
+                          true);
 }
 
 MappingType GameStarfield::mappings() const
@@ -307,3 +323,204 @@ int GameStarfield::nexusGameID() const
 {
   return 4187;
 }
+
+// Start Diagnose
+std::vector<unsigned int> GameStarfield::activeProblems() const
+{
+  std::vector<unsigned int> result;
+  if (m_Organizer->managedGame() == this) {
+    if (m_Organizer->pluginSetting(name(), "enable_esp_warning").toBool() &&
+        activeESP())
+      result.push_back(PROBLEM_ESP);
+    if (m_Organizer->pluginSetting(name(), "enable_esl_warning").toBool() &&
+        activeESL())
+      result.push_back(PROBLEM_ESL);
+    if (m_Organizer->pluginSetting(name(), "enable_overlay_warning").toBool() &&
+        activeOverlay())
+      result.push_back(PROBLEM_OVERLAY);
+    if (testFilePresent())
+      result.push_back(PROBLEM_TEST_FILE);
+    else if (pluginsTxtEnabler())
+      result.push_back(PROBLEM_PLUGINS_TXT);
+  }
+  return result;
+}
+
+bool GameStarfield::activeESP() const
+{
+  m_Active_ESPs.clear();
+  std::set<QString> enabledPlugins;
+
+  QStringList esps = m_Organizer->findFiles("", [](const QString& fileName) -> bool {
+    return fileName.endsWith(".esp", FileNameComparator::CaseSensitivity);
+  });
+
+  for (const QString& esp : esps) {
+    QString baseName = QFileInfo(esp).fileName();
+    if (m_Organizer->pluginList()->state(baseName) == IPluginList::STATE_ACTIVE) {
+      m_Active_ESPs.insert(baseName);
+    }
+  }
+
+  if (!m_Active_ESPs.empty())
+    return true;
+  return false;
+}
+
+bool GameStarfield::activeESL() const
+{
+  m_Active_ESLs.clear();
+  std::set<QString> enabledPlugins;
+
+  QStringList esps = m_Organizer->findFiles("", [](const QString& fileName) -> bool {
+    return fileName.endsWith(".esp", FileNameComparator::CaseSensitivity) ||
+           fileName.endsWith(".esm", FileNameComparator::CaseSensitivity) ||
+           fileName.endsWith(".esl", FileNameComparator::CaseSensitivity);
+  });
+
+  for (const QString& esp : esps) {
+    QString baseName = QFileInfo(esp).fileName();
+    if (primaryPlugins().contains(baseName, Qt::CaseInsensitive))
+      continue;
+    if (m_Organizer->pluginList()->state(baseName) == IPluginList::STATE_ACTIVE &&
+        !m_Organizer->pluginList()->hasNoRecords(baseName))
+      if (m_Organizer->pluginList()->hasLightExtension(baseName) ||
+          m_Organizer->pluginList()->isLightFlagged(baseName))
+        m_Active_ESLs.insert(baseName);
+  }
+
+  if (!m_Active_ESLs.empty())
+    return true;
+  return false;
+}
+
+bool GameStarfield::activeOverlay() const
+{
+  m_Active_Overlays.clear();
+  std::set<QString> enabledPlugins;
+
+  QStringList esps = m_Organizer->findFiles("", [](const QString& fileName) -> bool {
+    return fileName.endsWith(".esp", FileNameComparator::CaseSensitivity) ||
+           fileName.endsWith(".esm", FileNameComparator::CaseSensitivity) ||
+           fileName.endsWith(".esl", FileNameComparator::CaseSensitivity);
+  });
+
+  for (const QString& esp : esps) {
+    QString baseName = QFileInfo(esp).fileName();
+    if (primaryPlugins().contains(baseName, Qt::CaseInsensitive))
+      continue;
+    if (m_Organizer->pluginList()->state(baseName) == IPluginList::STATE_ACTIVE) {
+      if (m_Organizer->pluginList()->isOverlayFlagged(baseName))
+        m_Active_Overlays.insert(baseName);
+    }
+  }
+
+  if (!m_Active_Overlays.empty())
+    return true;
+  return false;
+}
+
+bool GameStarfield::testFilePresent() const
+{
+  if (m_Organizer->pluginSetting(name(), "enable_plugin_management").toBool() &&
+      !testFilePlugins().isEmpty())
+    return true;
+  return false;
+}
+
+bool GameStarfield::pluginsTxtEnabler() const
+{
+  if (sortMechanism() != SortMechanism::NONE) {
+    auto files = m_Organizer->findFiles("sfse\\plugins", {"sfpluginstxtenabler.dll"});
+    if (files.isEmpty())
+      return true;
+  }
+  return false;
+}
+
+QString GameStarfield::shortDescription(unsigned int key) const
+{
+  switch (key) {
+  case PROBLEM_ESP:
+    return tr("You have active ESP plugins in Starfield");
+  case PROBLEM_ESL:
+    return tr("You have active ESL plugins in Starfield");
+  case PROBLEM_OVERLAY:
+    return tr("You have active overlay plugins");
+  case PROBLEM_TEST_FILE:
+    return tr("sTestFile entries are present");
+  case PROBLEM_PLUGINS_TXT:
+    return tr("Plugins.txt Enabler missing");
+  }
+}
+
+QString GameStarfield::fullDescription(unsigned int key) const
+{
+  switch (key) {
+  case PROBLEM_ESP: {
+    QString espInfo = SetJoin(m_Active_ESPs, ", ");
+    return tr("<p>ESP plugins are not ideal for Starfield. In addition to being unable "
+              "to sort them alongside ESM or master-flagged plugins, certain record "
+              "references are always kept loaded by the game. This consumes "
+              "unnecessary resources and limits the game's ability to load what it "
+              "needs.</p>"
+              "<p>Ideally, plugins should be saved as ESM files upon release. It can "
+              "also be released as an ESL plugin, however there are additional "
+              "concerns with the way light plugins are currently handled and should "
+              "only be used when absolutely certain about what you're doing.</p>"
+              "<p>Notably, xEdit does not currently support saving ESP files.</p>"
+              "<h4>Current ESPs:</h4><p>%1</p>")
+        .arg(espInfo);
+  }
+  case PROBLEM_ESL: {
+    QString eslInfo = SetJoin(m_Active_ESLs, ", ");
+    return tr("<p>Light plugins work differently in Starfield. They use a different "
+              "base form ID compared with standard plugin files.</p>"
+              "<p>What this means is that you can't just change a standard plugin to a "
+              "light plugin at will, it can and will break any dependent plugin. If "
+              "you do so, be absolutely certain no other plugins use that plugin as a "
+              "master.</p>"
+              "<p>Notably, xEdit does not currently support saving or loading ESL "
+              "files under these conditions.<p>"
+              "<h4>Current ESLs:</h4><p>%1</p>")
+        .arg(eslInfo);
+  }
+  case PROBLEM_OVERLAY: {
+    QString overlayInfo = SetJoin(m_Active_Overlays, ", ");
+    return tr("<p>Overlay-flagged plugins are not currently recommended. In theory, "
+              "they should allow you to update existing records without utilizing "
+              "additional load order slots. Unfortunately, it appears that the game "
+              "still allocates the slots as if these were standard plugins. Therefore, "
+              "at the moment there is no real use for this plugin flag.</p>"
+              "<p>Notably, xEdit does not currently support saving or loading "
+              "overlay-flagged files under these conditions.</p>"
+              "<h4>Current Overlays:</h4><p>%1</p>")
+        .arg(overlayInfo);
+  }
+  case PROBLEM_TEST_FILE: {
+    return tr("<p>You have plugin managment enabled but you still have sTestFile "
+              "settings in your StarfieldCustom.ini. These must be removed or the game "
+              "will not read the plugins.txt file. Management is still disabled.</p>");
+  }
+  case PROBLEM_PLUGINS_TXT: {
+    return tr("<p>You have plugin management turned on but do not have the Plugins.txt "
+              "Enabler SFSE plugin installed. Plugin file management for Starfield "
+              "will not work without this SFSE plugin.</p>");
+  }
+  }
+}
+
+bool GameStarfield::hasGuidedFix(unsigned int key) const
+{
+  if (key == PROBLEM_PLUGINS_TXT)
+    return true;
+  return false;
+}
+
+void GameStarfield::startGuidedFix(unsigned int key) const
+{
+  if (key == PROBLEM_PLUGINS_TXT) {
+    QDesktopServices::openUrl(
+        QUrl("https://www.nexusmods.com/starfield/mods/4157?tab=files"));
+  }
+}

src/gamestarfield.h

@@ -2,14 +2,15 @@
 #define GAMESTARFIELD_H
 
 #include "gamegamebryo.h"
+#include "iplugindiagnose.h"
 
 #include <QObject>
 #include <QtGlobal>
 
-class GameStarfield : public GameGamebryo
+class GameStarfield : public GameGamebryo, public MOBase::IPluginDiagnose
 {
   Q_OBJECT
-
+  Q_INTERFACES(MOBase::IPlugin MOBase::IPluginGame MOBase::IPluginDiagnose)
   Q_PLUGIN_METADATA(IID "org.modorganizer.GameStarfield" FILE "gamestarfield.json")
 
 public:
@@ -45,6 +46,13 @@ class GameStarfield : public GameGamebryo
   virtual int nexusModOrganizerID() const override;
   virtual int nexusGameID() const override;
 
+public:  // IPluginDiagnose interface
+  virtual std::vector<unsigned int> activeProblems() const override;
+  virtual QString shortDescription(unsigned int key) const override;
+  virtual QString fullDescription(unsigned int key) const override;
+  virtual bool hasGuidedFix(unsigned int key) const override;
+  virtual void startGuidedFix(unsigned int key) const override;
+
 public:  // IPlugin interface
   virtual QString name() const override;
   virtual QString localizedName() const override;
@@ -59,6 +67,24 @@ class GameStarfield : public GameGamebryo
   std::shared_ptr<const GamebryoSaveGame> makeSaveGame(QString filePath) const override;
   QString savegameExtension() const override;
   QString savegameSEExtension() const override;
+
+private:
+  bool activeESP() const;
+  bool activeESL() const;
+  bool activeOverlay() const;
+  bool testFilePresent() const;
+  bool pluginsTxtEnabler() const;
+
+private:
+  static const unsigned int PROBLEM_ESP         = 1;
+  static const unsigned int PROBLEM_ESL         = 2;
+  static const unsigned int PROBLEM_OVERLAY     = 3;
+  static const unsigned int PROBLEM_TEST_FILE   = 4;
+  static const unsigned int PROBLEM_PLUGINS_TXT = 5;
+
+  mutable std::set<QString> m_Active_ESPs;
+  mutable std::set<QString> m_Active_ESLs;
+  mutable std::set<QString> m_Active_Overlays;
 };
 
 #endif  // GAMEStarfield_H