Managing games functioning

Author: ErikVeland-News

.gitignore

@@ -27,6 +27,9 @@ npm-debug.log*
 .DS_Store
 yarn-error.log
 
+# temporary files
+tmp.*
+
 # temporary fonts directory used during font-svg generation
 /fonts/
 

src/extensions/extension_manager/index.ts

@@ -129,10 +129,8 @@ function checkForUpdates(api: IExtensionApi) {
             displayMS: 5000,
           });
 
-          // Trigger dynamic update of game list if game extensions were updated
-          if (gameUpdates.length > 0) {
-            api.events.emit('refresh-game-list');
-          }
+          // Don't emit refresh-game-list here to prevent infinite loop
+          // The refresh will be handled by the caller if needed
         }
       }
     });
@@ -313,10 +311,8 @@ function genUpdateInstalledExtensions(api: IExtensionApi) {
               displayMS: 5000,
             });
 
-            // Trigger dynamic update of game list if game extensions were installed
-            if (newGameExtensions.length > 0) {
-              api.events.emit('refresh-game-list');
-            }
+            // Don't emit refresh-game-list here to prevent infinite loop
+            // The refresh will be handled by the caller if needed
           }
         }
         api.store.dispatch(setInstalledExtensions(ext));
@@ -388,6 +384,10 @@ function init(context: IExtensionContext) {
     });
 
   context.once(() => {
+    // Expose the updateExtensions function so it can be called from other modules
+    // This must be done in the once callback where the API is available
+    context.api.ext['updateExtensions'] = updateExtensions;
+    
     let onDidFetch: () => void;
     const didFetchAvailableExtensions = new Promise((resolve => onDidFetch = resolve));
     updateExtensions(true)
@@ -404,7 +404,23 @@ function init(context: IExtensionContext) {
         .then(success => {
           if (success) {
             return updateExtensions(false)
-              .then(() => success);
+              .then(() => {
+                // Check if any of the newly installed extensions are game extensions
+                // If so, emit refresh-game-list to update the UI
+                const state = context.api.getState();
+                const previousExtensions = state.session.extensions.installed || {};
+                const newExtensions = Object.keys(state.session.extensions.installed)
+                  .filter(extId => !previousExtensions[extId]);
+                const newGameExtensions = newExtensions
+                  .filter(extId => state.session.extensions.installed[extId].type === 'game');
+                          
+                if (newGameExtensions.length > 0) {
+                  // Emit refresh-game-list with forceFullDiscovery=true to ensure game extensions are properly registered
+                  context.api.events.emit('refresh-game-list', true);
+                }
+                        
+                return success;
+              });
           } else {
             return Promise.resolve()
               .then(() => success);

src/extensions/extension_manager/util.ts

@@ -255,6 +255,15 @@ export function downloadAndInstallExtension(api: IExtensionApi,
 
   let dlPromise: Promise<string[]>;
 
+  // Show activity notification for better UX
+  const notificationId = `installing-extension-${Date.now()}`;
+  api.sendNotification({
+    id: notificationId,
+    type: 'activity',
+    message: `Downloading ${ext.name}...`,
+    displayMS: 10000,
+  });
+
   if (truthy(ext.modId)) {
     dlPromise = downloadFromNexus(api, ext);
   } else if (truthy(ext.githubRawPath)) {
@@ -263,6 +272,8 @@ export function downloadAndInstallExtension(api: IExtensionApi,
     dlPromise = downloadGithubRelease(api, ext);
   } else {
     // don't report an error if the extension list contains invalid data
+    // Dismiss the activity notification
+    api.dismissNotification(notificationId);
     return Promise.resolve(false);
   }
 
@@ -272,14 +283,26 @@ export function downloadAndInstallExtension(api: IExtensionApi,
 
   return dlPromise
     .then((dlIds: string[]) => {
+      // Update notification to show installation phase
+      api.sendNotification({
+        id: notificationId,
+        type: 'activity',
+        message: `Installing ${ext.name}...`,
+        displayMS: 10000,
+      });
+      
       const state: IState = api.store.getState();
 
       if ((dlIds === undefined) || (dlIds.length !== 1)) {
+        // Dismiss the activity notification
+        api.dismissNotification(notificationId);
         return Promise.reject(new ProcessCanceled('No download found'));
       }
       api.store.dispatch(setDownloadModInfo(dlIds[0], 'internal', true));
       download = getSafe(state, ['persistent', 'downloads', 'files', dlIds[0]], undefined);
       if (download === undefined) {
+        // Dismiss the activity notification
+        api.dismissNotification(notificationId);
         return Promise.reject(new Error('Download not found'));
       }
 
@@ -304,9 +327,19 @@ export function downloadAndInstallExtension(api: IExtensionApi,
       const downloadPath = downloadPathForGame(state, SITE_ID);
       return installExtension(api, path.join(downloadPath, download.localPath), info);
     })
-    .then(() => Promise.resolve(true))
-    .catch(UserCanceled, () => null)
+    .then(() => {
+      // Dismiss the activity notification
+      api.dismissNotification(notificationId);
+      return Promise.resolve(true);
+    })
+    .catch(UserCanceled, () => {
+      // Dismiss the activity notification
+      api.dismissNotification(notificationId);
+      return null;
+    })
     .catch(ProcessCanceled, () => {
+      // Dismiss the activity notification
+      api.dismissNotification(notificationId);
       api.showDialog('error', 'Installation failed', {
         text: 'Failed to install the extension "{{extensionName}}" from "{{sourceName}}", '
             + 'please check the notifications.',
@@ -323,10 +356,14 @@ export function downloadAndInstallExtension(api: IExtensionApi,
       return Promise.resolve(false);
     })
     .catch(ServiceTemporarilyUnavailable, err => {
+      // Dismiss the activity notification
+      api.dismissNotification(notificationId);
       log('warn', 'Failed to download from github', { message: err.message });
       return Promise.resolve(false);
     })
     .catch(err => {
+      // Dismiss the activity notification
+      api.dismissNotification(notificationId);
       api.showDialog('error', 'Installation failed', {
         text: 'Failed to install the extension "{{extensionName}}" from "{{sourceName}}"',
         parameters: {

src/extensions/gamemode_management/index.ts

@@ -92,6 +92,9 @@ interface IProvider {
 
 const gameInfoProviders: IProvider[] = [];
 
+// Add this at the top of the file with the other module-level variables
+let isRefreshingGameList = false;
+
 function refreshGameInfo(store: Redux.Store<IState>, gameId: string): Promise<void> {
   interface IKeyProvider {
     [key: string]: { priority: number, provider: string };
@@ -239,9 +242,19 @@ function browseGameLocation(api: IExtensionApi, gameId: string): Promise<void> {
   const state: IState = api.store.getState();
 
   if (gameById(state, gameId) === undefined) {
-    return api.showDialog('question', 'Game support not installed', {
-      text: 'Support for this game is provided through an extension. '
-          + 'Please click "Manage" to install the extension and set it up.',
+    // Find the extension to get the game name
+    const extension = state.session.extensions.available.find(ext =>
+      (ext?.gameId === gameId) || (ext.name === gameId));
+    
+    // Get the game name for better user messaging
+    const gameName = extension?.gameName || extension?.name?.replace(/^Game: /, '') || 'this game';
+    
+    return api.showDialog('question', 'Game Support Not Installed', {
+      text: 'Support for {{gameName}} is provided through a community extension that is not included with the main Vortex application. '
+          + 'To manage mods for {{gameName}}, you need to download and install this extension.',
+      parameters: {
+        gameName
+      }
     }, [
       { label: 'Close' },
     ])
@@ -857,10 +870,169 @@ function init(context: IExtensionContext): boolean {
         .catch(err => callback(err));
     });
 
-    events.on('refresh-game-list', () => {
+    events.on('refresh-game-list', (forceFullDiscovery?: boolean) => {
       // Refresh the known games list when game extensions are installed
-      $.gameModeManager.refreshKnownGames();
-      log('info', 'Game list refreshed after extension installation');
+      if (forceFullDiscovery) {
+        // Force a complete refresh including re-reading game extensions
+        // Use the extension manager's exposed update function if available
+        if (context.api.ext['updateExtensions']) {
+          // Add a flag to prevent infinite loop
+          if (isRefreshingGameList) {
+            // Already refreshing, skip to prevent infinite loop
+            return;
+          }
+          
+          // Set the flag to indicate we're refreshing
+          isRefreshingGameList = true;
+          
+          context.api.ext['updateExtensions'](false)
+            .then(() => {
+              // After updating extensions, we need to ensure game extensions are properly registered
+              // Re-initialize the extension games list to capture any newly installed game extensions
+              $.extensionGames = [];
+              
+              // Get the current state and re-process all installed game extensions
+              const state = context.api.getState();
+              const installedExtensions = state.session.extensions.installed;
+              
+              // Process each installed game extension to ensure it's registered
+              return Promise.map(Object.keys(installedExtensions), extId => {
+                const ext = installedExtensions[extId];
+                if (ext.type === 'game' && ext.path) {
+                  try {
+                    // Try to load and register the game extension
+                    const indexPath = path.join(ext.path, 'index.js');
+                    return fs.statAsync(indexPath)
+                      .then(() => {
+                        const extensionModule = require(indexPath);
+                        if (typeof extensionModule.default === 'function') {
+                          // Create a minimal context for the extension to register its game
+                          const contextProxy = new Proxy({
+                            api: context.api,
+                            registerGame: (game: IGame) => {
+                              // Register the game in our extension games list
+                              game.extensionPath = ext.path;
+                              $.extensionGames.push(game);
+                            },
+                            registerGameStub: (game: IGame, extInfo: IExtensionDownloadInfo) => {
+                              // Handle game stubs if needed
+                              $.extensionStubs.push({ ext: extInfo, game });
+                            }
+                          }, {
+                            get: (target, prop) => {
+                              // Provide stub functions for other register methods
+                              if (prop === 'registerGame' || prop === 'registerGameStub') {
+                                return target[prop];
+                              } else if (typeof prop === 'string' && prop.startsWith('register')) {
+                                return () => {}; // Stub for other register methods
+                              }
+                              return target[prop];
+                            }
+                          });
+                          
+                          // Call the extension's init function
+                          extensionModule.default(contextProxy);
+                        }
+                        return Promise.resolve();
+                      })
+                      .catch(() => {
+                        // File doesn't exist or other error, skip this extension
+                        return Promise.resolve();
+                      });
+                  } catch (err) {
+                    log('warn', 'Failed to load game extension', { extension: ext.name, error: err.message });
+                    return Promise.resolve();
+                  }
+                }
+                return Promise.resolve();
+              })
+              .then(() => {
+                // Refresh the known games with the updated extension games list
+                const gamesStored: IGameStored[] = $.extensionGames
+                  .map(game => ({
+                    name: game.name,
+                    shortName: game.shortName,
+                    id: game.id,
+                    logo: game.logo,
+                    extensionPath: game.extensionPath,
+                    contributed: game.contributed,
+                    final: game.final,
+                    version: game.version,
+                    executable: game.executable?.(),
+                    requiredFiles: game.requiredFiles,
+                    environment: game.environment,
+                    details: game.details,
+                  }))
+                  .filter(game => 
+                    (game.executable !== undefined) &&
+                    (game.requiredFiles !== undefined) &&
+                    (game.name !== undefined)
+                  );
+                context.api.store.dispatch(setKnownGames(gamesStored));
+                
+                // Also run quick discovery to find the game paths
+                return $.gameModeManager.startQuickDiscovery(undefined, false);
+              });
+            })
+            .then(() => {
+              log('info', 'Game list fully refreshed after extension installation');
+              // Clear the flag when done
+              isRefreshingGameList = false;
+            })
+            .catch(err => {
+              log('error', 'Failed to refresh game list', err.message);
+              // Clear the flag on error
+              isRefreshingGameList = false;
+            });
+        } else {
+          // Fallback if the update function is not available
+          const gamesStored: IGameStored[] = $.extensionGames
+            .map(game => ({
+              name: game.name,
+              shortName: game.shortName,
+              id: game.id,
+              logo: game.logo,
+              extensionPath: game.extensionPath,
+              contributed: game.contributed,
+              final: game.final,
+              version: game.version,
+              executable: game.executable?.(),
+              requiredFiles: game.requiredFiles,
+              environment: game.environment,
+              details: game.details,
+            }))
+            .filter(game => 
+              (game.executable !== undefined) &&
+              (game.requiredFiles !== undefined) &&
+              (game.name !== undefined)
+            );
+          context.api.store.dispatch(setKnownGames(gamesStored));
+          log('info', 'Game list refreshed after extension installation');
+        }
+      } else {
+        const gamesStored: IGameStored[] = $.extensionGames
+          .map(game => ({
+            name: game.name,
+            shortName: game.shortName,
+            id: game.id,
+            logo: game.logo,
+            extensionPath: game.extensionPath,
+            contributed: game.contributed,
+            final: game.final,
+            version: game.version,
+            executable: game.executable?.(),
+            requiredFiles: game.requiredFiles,
+            environment: game.environment,
+            details: game.details,
+          }))
+          .filter(game => 
+            (game.executable !== undefined) &&
+            (game.requiredFiles !== undefined) &&
+            (game.name !== undefined)
+          );
+        context.api.store.dispatch(setKnownGames(gamesStored));
+        log('info', 'Game list refreshed after extension installation');
+      }
     });
 
     const changeGameMode = (oldGameId: string, newGameId: string,