fix some game doesn't show up

Author: devsayed2602

src/mainwindow.cpp

@@ -214,15 +214,21 @@ void MainWindow::startSync() {
     m_syncWorker->start();
 }
 
-void MainWindow::onSyncDone(QSet<QString> appIds) {
-    m_cachedAppIds = appIds;
+void MainWindow::onSyncDone(QList<GameInfo> games) {
+    m_supportedGames = games;
     m_spinner->stop();
     m_stack->setCurrentIndex(1); // List
-    m_statusLabel->setText(QString("Online • %L1 supported games")
-                          .arg(appIds.size()));
+    m_statusLabel->setText(QString("Online • %1 supported games")
+                          .arg(games.size()));
     m_searchInput->setFocus();
+    
+    // Trigger initial empty search to show list if needed, or just clear
+    if (!m_searchInput->text().isEmpty()) {
+        doSearch();
+    }
 }
 
+
 void MainWindow::onSyncError(QString error) {
     m_spinner->stop();
     m_stack->setCurrentIndex(1);
@@ -245,8 +251,24 @@ void MainWindow::doSearch() {
     if (query.isEmpty()) return;
 
     m_currentSearchId++;
-    m_statusLabel->setText("Searching Store...");
+    m_statusLabel->setText("Searching...");
+    
+    // 1. Local Search (Instant)
+    QJsonArray localResults;
+    for (const auto& game : m_supportedGames) {
+        if (game.name.contains(query, Qt::CaseInsensitive) || game.id == query) {
+            QJsonObject item;
+            item["id"] = game.id;
+            item["name"] = game.name;
+            item["supported_local"] = true; // Marker for local result
+            localResults.append(item);
+        }
+    }
+    
+    // Display local results immediately
+    displayResults(localResults);
 
+    // 2. Remote Search (Fallback/Supplement)
     if (m_activeReply) {
         m_activeReply->abort();
     }
@@ -263,26 +285,99 @@ void MainWindow::doSearch() {
     m_activeReply->setProperty("sid", m_currentSearchId);
 }
 
+
 void MainWindow::onSearchFinished(QNetworkReply* reply) {
     reply->deleteLater();
     m_activeReply = nullptr;
 
     if (reply->error() == QNetworkReply::OperationCanceledError) return;
-    if (reply->property("sid").toInt() != m_currentSearchId) return;
+    int sid = reply->property("sid").toInt();
+    if (sid != m_currentSearchId) return;
 
     if (reply->error() != QNetworkReply::NoError) {
-        m_statusLabel->setText("Search failed");
+        // Don't clear list if we have local results
+        if (m_resultsList->count() == 0) {
+            m_statusLabel->setText("Store search failed");
+        }
         return;
     }
 
     QByteArray data = reply->readAll();
     QJsonDocument doc = QJsonDocument::fromJson(data);
     QJsonObject obj = doc.object();
-    QJsonArray items = obj["items"].toArray();
+    QJsonArray remoteItems = obj["items"].toArray();
+    
+    // Merge remote items with existing local items
+    // We strictly prefer local items because they are known supported
+    
+    QSet<QString> existingIds;
+    for (int i = 0; i < m_resultsList->count(); ++i) {
+        QMap<QString, QString> data = m_resultsList->item(i)->data(Qt::UserRole).value<QMap<QString, QString>>();
+        existingIds.insert(data["appid"]);
+    }
+    
+    bool addedRemote = false;
+    QJsonArray mergedItems;
+    
+    // Re-add existing (local) items to the list to keep order or just append new ones?
+    // Let's just append new remote ones for now to avoid flickering
 
-    displayResults(items);
+    QList<QJsonObject> newItems;
+    for (const QJsonValue& val : remoteItems) {
+        QJsonObject item = val.toObject();
+        QString id = QString::number(item["id"].toInt());
+        
+        if (!existingIds.contains(id)) {
+            newItems.append(item);
+            addedRemote = true;
+        }
+    }
+    
+    if (addedRemote) {
+        // Append to UI
+        for (const auto& item : newItems) {
+           QString name = item["name"].toString("Unknown");
+           QString appid = QString::number(item["id"].toInt());
+           
+           // Check support again (in case it's in our support list but wasn't found by local string match?)
+           // Although local search should have found it if name matched.
+           // But maybe name in steam api differs from our index.
+           
+           bool supported = false;
+           for(const auto& g : m_supportedGames) {
+               if(g.id == appid) {
+                   supported = true; 
+                   break;
+               }
+           }
+           
+           QString statusText = supported ? "Supported" : "Not Indexed";
+           QString displayText = QString("%1\n%2 • ID: %3")
+                                .arg(name).arg(statusText).arg(appid);
+           
+           QListWidgetItem* listItem = new QListWidgetItem(displayText);
+           
+           QMap<QString, QString> data;
+           data["name"] = name;
+           data["appid"] = appid;
+           data["supported"] = supported ? "true" : "false";
+           listItem->setData(Qt::UserRole, QVariant::fromValue(data));
+           
+           listItem->setIcon(createStatusIcon(supported));
+           
+           if (supported) {
+               listItem->setForeground(Colors::toQColor(Colors::ACCENT_GREEN));
+           } else {
+               listItem->setForeground(Colors::toQColor(Colors::TEXT_SECONDARY));
+           }
+           
+           m_resultsList->addItem(listItem);
+        }
+        m_statusLabel->setText(QString("Found %1 results").arg(m_resultsList->count()));
+    }
 }
 
+
 QIcon MainWindow::createStatusIcon(bool supported) {
     int size = 64;
     QPixmap pixmap(size, size);
@@ -323,15 +418,29 @@ void MainWindow::displayResults(const QJsonArray& items) {
     m_btnPatch->setEnabled(false);
 
     if (items.isEmpty()) {
-        m_statusLabel->setText("No results found");
-        return;
+        // m_statusLabel->setText("No results found"); // Don't show this yet, might be waiting for remote
+        return; 
     }
 
     for (const QJsonValue& val : items) {
         QJsonObject item = val.toObject();
         QString name = item["name"].toString("Unknown");
-        QString appid = QString::number(item["id"].toInt());
-        bool supported = m_cachedAppIds.contains(appid);
+        QString appid = item.contains("id") ? (item["id"].isString() ? item["id"].toString() : QString::number(item["id"].toInt())) : "0";
+        bool supported = false;
+        
+        // If it came from local search, we know it's supported
+        if (item.contains("supported_local")) {
+            supported = true;
+        } else {
+            // Double check
+             for(const auto& g : m_supportedGames) {
+               if(g.id == appid) {
+                   supported = true; 
+                   break;
+               }
+           }
+        }
+
 
         QString statusText = supported ? "Supported" : "Not Indexed";
         QString displayText = QString("%1\n%2 • ID: %3")

src/mainwindow.h

@@ -15,8 +15,11 @@
 #include <QNetworkReply>
 
 class GlassButton;
+#include "utils/gameinfo.h"
+
 class LoadingSpinner;
 class IndexDownloadWorker;
+
 class LuaDownloadWorker;
 class RestartWorker;
 
@@ -31,7 +34,8 @@ class MainWindow : public QMainWindow {
     void paintEvent(QPaintEvent* event) override;
 
 private slots:
-    void onSyncDone(QSet<QString> appIds);
+    void onSyncDone(QList<GameInfo> games);
+
     void onSyncError(QString error);
     void onSearchChanged(const QString& text);
     void doSearch();
@@ -59,7 +63,8 @@ private slots:
     GlassButton* m_btnRestart;
 
     // Data
-    QSet<QString> m_cachedAppIds;
+    QList<GameInfo> m_supportedGames;
+
     QMap<QString, QString> m_selectedGame; // name, appid, supported
 
     // Network

src/utils/gameinfo.h

@@ -0,0 +1,20 @@
+#ifndef GAMEINFO_H
+#define GAMEINFO_H
+
+#include <QString>
+
+struct GameInfo {
+    QString id;
+    QString name;
+    
+    bool operator==(const GameInfo& other) const {
+        return id == other.id;
+    }
+    
+    // For QSet or hashing if needed later
+    friend uint qHash(const GameInfo& key, uint seed = 0) {
+        return qHash(key.id, seed);
+    }
+};
+
+#endif // GAMEINFO_H

src/workers/indexdownloadworker.cpp

@@ -76,13 +76,16 @@ void IndexDownloadWorker::run() {
         reply->deleteLater();
 
         // Extract app IDs
-        QSet<QString> appIds;
-        QJsonArray arr = indexData["app_ids"].toArray();
+        // Extract games
+        QList<GameInfo> games;
+        QJsonArray arr = indexData["games"].toArray();
         for (const QJsonValue& val : arr) {
-            appIds.insert(val.toString());
+            QJsonObject obj = val.toObject();
+            games.append({obj["id"].toString(), obj["name"].toString()});
         }
 
-        emit finished(appIds);
+        emit finished(games);
+
 
     } catch (const std::exception& e) {
         emit error(QString::fromStdString(e.what()));

src/workers/indexdownloadworker.h

@@ -3,6 +3,8 @@
 
 #include <QThread>
 #include <QSet>
+#include "../utils/gameinfo.h"
+
 #include <QString>
 
 class IndexDownloadWorker : public QThread {
@@ -12,7 +14,8 @@ class IndexDownloadWorker : public QThread {
     explicit IndexDownloadWorker(QObject* parent = nullptr);
 
 signals:
-    void finished(QSet<QString> appIds);
+    void finished(QList<GameInfo> games);
+
     void progress(QString message);
     void error(QString errorMessage);
 

webserver/generate_index.py

@@ -1,39 +1,72 @@
 """
 Generate games_index.json from all Lua files in the games directory.
 This script is run by the GitHub Actions workflow on each push.
+It fetches game names from the Steam API to create a rich index.
 """
 
 import os
 import json
+import requests
+import time
 
+STEAM_APP_LIST_URL = "http://api.steampowered.com/ISteamApps/GetAppList/v2"
+
+def get_steam_app_map():
+    """Fetch all steam apps and return a dict of {app_id: name}."""
+    try:
+        print("Fetching Steam App List...")
+        response = requests.get(STEAM_APP_LIST_URL, timeout=30)
+        response.raise_for_status()
+        data = response.json()
+        
+        app_map = {}
+        for app in data['applist']['apps']:
+            app_map[str(app['appid'])] = app['name']
+            
+        print(f"Fetched {len(app_map)} apps from Steam.")
+        return app_map
+    except Exception as e:
+        print(f"Error fetching Steam App List: {e}")
+        return {}
 
 def generate_index():
-    """Scan games directory and generate JSON index of all app IDs."""
+    """Scan games directory and generate JSON index of all supported games with names."""
     games_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'games')
 
-    app_ids = []
+    # Get mapping of AppID -> Name
+    app_map = get_steam_app_map()
+    
+    games_list = []
 
     if os.path.exists(games_dir):
         for filename in os.listdir(games_dir):
             if filename.endswith('.lua'):
                 # Extract app ID from filename (e.g., "730.lua" -> "730")
                 app_id = filename[:-4]
-                app_ids.append(app_id)
+                
+                # Get name from map, or fallback to generic
+                name = app_map.get(app_id, f"Unknown Game ({app_id})")
+                
+                games_list.append({
+                    "id": app_id,
+                    "name": name
+                })
 
-    # Sort for consistent output
-    app_ids.sort(key=lambda x: int(x) if x.isdigit() else 0)
+    # Sort by name for easier reading, though client might resort
+    games_list.sort(key=lambda x: x['name'])
 
     index_data = {
-        'app_ids': app_ids,
-        'count': len(app_ids)
+        'games': games_list,
+        'count': len(games_list),
+        'last_updated': int(time.time())
     }
 
     # Write to root of webserver folder
     output_path = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'games_index.json')
-    with open(output_path, 'w') as f:
-        json.dump(index_data, f)
+    with open(output_path, 'w', encoding='utf-8') as f:
+        json.dump(index_data, f, ensure_ascii=False, indent=2)
 
-    print(f"Generated games_index.json with {len(app_ids)} app IDs")
+    print(f"Generated games_index.json with {len(games_list)} supported games.")
     return output_path
 
 

webserver/requirements.txt

@@ -1,2 +1,4 @@
 Flask
 gunicorn
+requests
+